标签: one-to-one

我看不出多对一关系与OneToOne关系的架构有什么不同:

@Entity
public class Order {

    @ManyToOne
    @JoinColumn(nullable = false)
    private Address address;

VS

@Entity
public class Order {

    @OneToOne
    @JoinColumn(nullable = false)
    private Address address;

有什么区别吗？

这是我的数据库结构,MySQL中的一对一映射:

这是我的java文件:

public class Employee {

private EmployeeDetail empdetail;
private String firstname;
private String lastname;

// getters and setters 

}


public class EmployeeDetail {
    private Employee employee ;
    private int employee_id;
    private String street;
    private String city;
    private String state;
    private String country;

// getters and setters 

}

这是我的映射文件:

<hibernate-mapping>

     <class name="Employee" table="employee">
        <id name="employee_id"  type="java.lang.Integer"  column="employee_id">
            <generator class="assigned" />
        </id>
        <one-to-one name="empdetail" class="EmployeeDetail"
            cascade="all"></one-to-one>

        <property name="firstname" type="java.lang.String" column="firstname" />
        <property name="lastname" type="java.lang.String" column="lastname" />

    </class>



 <class name="EmployeeDetail" table="employeedetail">
        <id …

我想使用EF Code First在现有数据库中映射可选的1对1关系.

简单架构:

User
 Username
 ContactID

Contact
 ID
 Name

显然ContactID加入了Contact.ID.ContactID字段可以为空,因此关系是可选的 - 0或1,从不多.

那么如何使用现有模式在EF Code First中指定此关系？

这是我到目前为止所尝试的:

public class User
{
    [Key]
    public string Username { get; set; }
    public int? ContactID { get; set; }

    [ForeignKey("ContactID")]
    public virtual Contact Contact { get; set; }
}

public class Contact
{
    [Key]
    public int ID { get; set; }
    public string Name { get; set; }

    public virtual User User { get; set; }
}

modelBuilder.Entity<User>().HasOptional<Contact>(u=> u.Contact)
    .WithOptionalDependent(c => c.User);

我得到以下例外: …

(很长一段时间)我一直在寻找一个如何使用Fluent NHibernate 正确实现一对一映射的示例.

我找到的大多数资源都说:

我认为你的意思是多对一的

然而,没有人真正举例说明如何正确实现一对一关系.

那么,你能用Fluent NHibernate给出一对一的映射示例吗？

注意:我对那些说"你的模型是什么,你可能真的需要HasMany "的人不感兴趣.不,谢谢,我只需要一对一的例子.

更确切地说,我知道语法.这是我自己搜索唯一能找到的东西.我正在寻找的是一个更完整的例子,包括一个((非常)简单的)数据库设置,以及参与该关系的所有实体的整个映射,我认为它对Stack Overflow来说具有合理的大小.

我在Django中有两个与OneToOneField(PrinterProfile和PrinterAdress)相关的模型.我试图用PrinterProfileForm做一个表单,但由于某种原因它不会将PrinterAddress字段传递给表单(它不是由模板中的Django"magic"呈现的).

我应该怎么做,以便我的PrinterProfileForm包括PrinterAddress(其相关的OneToOneField)中的字段？

非常感谢

class PrinterProfile(TimeStampedModel):
    user = models.OneToOneField(User)
    phone_number = models.CharField(max_length=120, null=False, blank=False)
    additional_notes = models.TextField()
    delivery = models.BooleanField(default=False)
    pickup = models.BooleanField(default=True)


# The main address of the profile, it will be where are located all the printers.    
class PrinterAddress(TimeStampedModel):
    printer_profile = models.OneToOneField(PrinterProfile)
    formatted_address = models.CharField(max_length=200, null=True)
    latitude = models.DecimalField(max_digits=25, decimal_places=20)  # NEED TO CHECK HERE THE PRECISION NEEDED.
    longitude = models.DecimalField(max_digits=25, decimal_places=20)  # NEED TO CHECK HERE THE PRECISION NEEDED.
    point = models.PointField(srid=4326)

    def __unicode__(self, ):
        return self.user.username

class …

我在Symfony2和两个关联实体中遇到了Doctrine2的问题.

有一个用户实体可以(不一定)有一个引用的usermeta实体,其中包含传记等信息.

usermeta是可选的,因为用户是由另一个系统导入的,而usermeta是在我的应用程序中管理的.

当然我想将两者保存在一起,以便保存用户必须创建或更新usermeta-entity.

两者都由名为aduserid的列连接(两个表中的名称相同).

我已经认识到,如果usermeta是一个可选引用,在这种情况下,拥有方应该是usermeta,否则doctrine会加载用户并需要usermeta实体 - 但它并不总是存在.

请注意User-> setMeta中的注释..

/**
 * User
 *
 * @ORM\Table(name="user")
 * @ORM\Entity
 */
class User
{
/**
 * @var Usermeta
 * @ORM\OneToOne(targetEntity="Usermeta", mappedBy="user", cascade={"persist"})
 */
protected $meta;

public function getMeta()
{
    return $this->meta;
}

/**
 * 
 * @param Usermeta $metaValue 
 */
public function setMeta($metaValue)
{        
// I've tried setting the join-column-value here 
//  - but it's not getting persisted
// $metaValue->setAduserid($this->getAduserid());

// Then I've tried to set the user-object in Usermeta - …

我试图让Hibernate @OneToOne注释工作,而且在这里没有取得多大成功......

假设我有一个名为的表status,如下所示:

+------------------------------------------------+
|                     status                     |
+------------------------------------------------+
| id | frn_user_id | frn_content_id |   status   |
+----+-------------+----------------+------------+
|  1 |     111     |        0       |  "active"  |
+----+-------------+----------------+------------+
|  2 |      0      |       222      | "inactive" |
+----+-------------+----------------+------------+

我有一个实体User,看起来像这样:

@Entity
@Table(name = "user")
public class User {
    @Id
    @GeneratedValue(strategy = GenerationType.AUTO)
    @Column(name = "id", nullable = false)
    private Integer id;

    @OneToOne(cascade = CascadeType.ALL, fetch = FetchType.EAGER, mappedBy = "userId")
    private Status status;

    // getters and setters …

我需要建立一对一的关系,这种关系也必须是通用的.也许你可以建议我一个更好的设计.到目前为止,我提出了以下模型

class Event(models.Model):
    # skip event related fields...
    content_type      = models.ForeignKey(ContentType)
    object_id         = models.PositiveIntegerField()
    content_object    = generic.GenericForeignKey('content_type', 'object_id')

    class Meta:
        unique_together   = ('content_type', 'object_id')

class Action1(models.Model):
    # skip action1 related fields...
    events = generic.GenericRelation(Event, content_type_field='content_type', object_id_field='object_id')

    @property
    def event(self):
        return self.events.get() # <<<<<< Is this reasonable?

class Action2(models.Model):...

在事件列表中的Django Admin中,我想收集所有操作,然后从那里我想去管理页面进行操作.是否有可能避免event在动作模型中创建属性？有更好的解决方案吗？将字段events和属性组合event在一个定义中会很好.我正在使用的项目使用Django 1.1

我很难弄清楚何时在数据库设计中使用1对1的关系,或者是否有必要.

如果您只能在查询中选择所需的列,则有必要将表拆分为1对1关系.我想更新一个大表对性能的影响比一个较小的表更多,我确信它取决于表用于某些操作的重量(读/写)

因此,在设计数据库模式时,如何将一对一关系考虑在内？您使用什么标准来确定是否需要一个标准,而不使用标准有什么好处？

谢谢!

我有User和Address类如下:

class User
{
   ...
   ...
   @OneToOne( cascade=CascadeType.ALL)
   @JoinColumn(name="addr_id")
   private Address address;
}

class Address
{
   ...
   ...
   @OneToOne(mappedBy="address")
   private User user;
}

这里我的假设是这个域模型我可以将一个地址与一个用户关联(user.addr_id应该是唯一的).

但是使用这个域模型,我可以创建多个用户并将它们关联到同一个地址.

User u1 = new User();
//set data
Address addr1 = new Address();
//set data
u1.setAddress(addr1);
...
session.save(u1); 

- >这是使用addr_id = 1创建一个地址记录,并在用户表中使用addr_id = 1插入一个用户记录.精细.

再次,

User u2 = new User();
//set data
Address addr1 = (Address) session.load(Address.class, 1);
//set data
u2.setAddress(addr1);
...
session.save(u2);

- >这是创建第二个用户记录并使用addr_id = 1与现有地址相关联,这是不希望的.

我可以使用@OneToOne(..)@ JoinColumn(name ="addr_id",unique = true)来阻止这种情况.但是使用@OneToOne而不是@ManyToOne(..,unique = true)会有什么不同.

@OneToOne本身应该强加"unique = …