Database design 在其他两个实体之间共享一个实体的类型

我正在使用TypeORM开发NestJS应用程序，有一个

个人

实体和一个

业务

实体。这些实体中的每一个都可以有0个或多个

地址

e。无论是针对

业务

还是

人员

，地址字段都是相同的。因此，我希望将所有地址放在一个表中，而不是管理

PersonalAddress

和

BusinessAddress

表（前提是这是设计数据库的“正确”方法）

目前，这里是我的

个人

和

地址

实体的一部分：

// person.entity.ts
export class Person {
  @OneToMany(() => Address, (address) => address.person, { cascade: true})
  addresses: PersonAddress[]
}

// address.entity.ts
export class Address {

  @ManyToOne(() => Person, (person) => person.addresses)
  person: Person
}

我相信对于TypeORM来说，这是正确的方法，但是我希望能够删除

Address

中对

Person

的引用，这样我就可以在

业务

中使用相同的实体

现在，我的问题分为两部分：

我想要的设计是设计数据库的正确方法吗？我有使用数据库和查询数据库的经验，但没有设计数据库的经验。如果我试图做的是糟糕的数据库设计，那么我将继续为

Business

和

Person

的地址创建一个单独的实体

如果我想要的设计是正确的，我如何在TypeORM中定义实体来实现这个结果

---

我假设实体

业务

和

人员

之间没有关系

当前数据库设计中存在一个问题-

删除一个人将删除与该特定人关联的所有地址。如果同一地址（由于删除某人而被删除）与某些业务关联，则会导致问题

我宁愿创建一个单独的链接表

BusinessAndPersonAddress

，其中

businessId

和

personId

是外键。这样，您可以将同一地址与多个企业和个人关联

---

在这种情况下，删除person将仅删除链接表

businessandPersonalAddress

中与被删除人员相关联的地址条目，以及与某些业务相关联的地址条目，不会受到影响。

我假设实体

业务

和

人员

之间没有关系

当前数据库设计中存在一个问题-

删除一个人将删除与该特定人关联的所有地址。如果同一地址（由于删除某人而被删除）与某些业务关联，则会导致问题

我宁愿创建一个单独的链接表

BusinessAndPersonAddress

，其中

businessId

和

personId

是外键。这样，您可以将同一地址与多个企业和个人关联

在这种情况下，删除person将仅删除链接表

businessandPersonalAddress

中与被删除的人相关联的地址条目，并且地址条目（如果与某些业务相关）将不受影响

我想要的设计是设计数据库的正确方法吗

是的，您想要一个命名的数据库。一般来说，有一些规则，一般来说，你想坚持这些规则，除非你有一个很好的理由。ORM通常已经应用了这些规则，例如，每个表都需要有一个id列

如何在TypeForm中定义实体以实现此结果

TypeOrm允许您单方面定义多个关系，但不能反过来定义

@没有@manytone，一个公司就无法生存。如果要使用@OneToMany，则需要@ManyToOne。但是，不需要相反的结果：如果您只关心@manytone关系，那么您可以定义它，而不必在相关实体上使用@OneToMany

这将使：

person.entity.ts

export class Person {
  @Column()
  name: string

  // etc...

  @OneToMany(() => Address, (address) => address.person)
  addresses: Address[]
}

export class Business {
  @Column()
  name: string

  // etc...

  @OneToMany(() => Address, (address) => address.business)
  addresses: Address[]
}

export class Address {
  @Column()
  name: string

  // etc...

  @ManyToOne(() => Person, (p) => p.addresses)
  person: Person

  @ManyToOne(() => Business , (b) => b.addresses)
  business: Business
}

export class Person {
  @Column()
  name: string

  // etc...

  @ManyToMany(() => Address)
  addresses: Address[]
}

export class Business {
  @Column()
  name: string

  // etc...

  @ManyToMany(() => Address)
  addresses: Address[]
}

export class Address {
  @Column()
  name: string

  // etc...
}

business.entity.ts

export class Person {
  @Column()
  name: string

  // etc...

  @OneToMany(() => Address, (address) => address.person)
  addresses: Address[]
}

export class Business {
  @Column()
  name: string

  // etc...

  @OneToMany(() => Address, (address) => address.business)
  addresses: Address[]
}

export class Address {
  @Column()
  name: string

  // etc...

  @ManyToOne(() => Person, (p) => p.addresses)
  person: Person

  @ManyToOne(() => Business , (b) => b.addresses)
  business: Business
}

export class Person {
  @Column()
  name: string

  // etc...

  @ManyToMany(() => Address)
  addresses: Address[]
}

export class Business {
  @Column()
  name: string

  // etc...

  @ManyToMany(() => Address)
  addresses: Address[]
}

export class Address {
  @Column()
  name: string

  // etc...
}

address.entity.ts

export class Person {
  @Column()
  name: string

  // etc...

  @OneToMany(() => Address, (address) => address.person)
  addresses: Address[]
}

export class Business {
  @Column()
  name: string

  // etc...

  @OneToMany(() => Address, (address) => address.business)
  addresses: Address[]
}

export class Address {
  @Column()
  name: string

  // etc...

  @ManyToOne(() => Person, (p) => p.addresses)
  person: Person

  @ManyToOne(() => Business , (b) => b.addresses)
  business: Business
}

export class Person {
  @Column()
  name: string

  // etc...

  @ManyToMany(() => Address)
  addresses: Address[]
}

export class Business {
  @Column()
  name: string

  // etc...

  @ManyToMany(() => Address)
  addresses: Address[]
}

export class Address {
  @Column()
  name: string

  // etc...
}

如果您坚持不在您的地址中包含

多通电话

，您可以通过建立关系来避免这种情况。请记住，这将以更大的查询和更多的表的形式产生一些开销。这是因为多对多将创建一个联接表，需要额外的联接才能从数据库中获取数据。这一切都由orm tho负责

这将使：

person.entity.ts

export class Person {
  @Column()
  name: string

  // etc...

  @OneToMany(() => Address, (address) => address.person)
  addresses: Address[]
}

export class Business {
  @Column()
  name: string

  // etc...

  @OneToMany(() => Address, (address) => address.business)
  addresses: Address[]
}

export class Address {
  @Column()
  name: string

  // etc...

  @ManyToOne(() => Person, (p) => p.addresses)
  person: Person

  @ManyToOne(() => Business , (b) => b.addresses)
  business: Business
}

export class Person {
  @Column()
  name: string

  // etc...

  @ManyToMany(() => Address)
  addresses: Address[]
}

export class Business {
  @Column()
  name: string

  // etc...

  @ManyToMany(() => Address)
  addresses: Address[]
}

export class Address {
  @Column()
  name: string

  // etc...
}

business.entity.ts

export class Person {
  @Column()
  name: string

  // etc...

  @OneToMany(() => Address, (address) => address.person)
  addresses: Address[]
}

export class Business {
  @Column()
  name: string

  // etc...

  @OneToMany(() => Address, (address) => address.business)
  addresses: Address[]
}

export class Address {
  @Column()
  name: string

  // etc...

  @ManyToOne(() => Person, (p) => p.addresses)
  person: Person

  @ManyToOne(() => Business , (b) => b.addresses)
  business: Business
}

export class Person {
  @Column()
  name: string

  // etc...

  @ManyToMany(() => Address)
  addresses: Address[]
}

export class Business {
  @Column()
  name: string

  // etc...

  @ManyToMany(() => Address)
  addresses: Address[]
}

export class Address {
  @Column()
  name: string

  // etc...
}

address.entity.ts

export class Person {
  @Column()
  name: string

  // etc...

  @OneToMany(() => Address, (address) => address.person)
  addresses: Address[]
}

export class Business {
  @Column()
  name: string

  // etc...

  @OneToMany(() => Address, (address) => address.business)
  addresses: Address[]
}

export class Address {
  @Column()
  name: string

  // etc...

  @ManyToOne(() => Person, (p) => p.addresses)
  person: Person

  @ManyToOne(() => Business , (b) => b.addresses)
  business: Business
}

export class Person {
  @Column()
  name: string

  // etc...

  @ManyToMany(() => Address)
  addresses: Address[]
}

export class Business {
  @Column()
  name: string

  // etc...

  @ManyToMany(() => Address)
  addresses: Address[]
}

export class Address {
  @Column()
  name: string

  // etc...
}

我想要的设计是设计数据库的正确方法吗

是的，您想要一个命名的数据库。一般来说，有一些规则，一般来说，你想坚持这些规则，除非你有一个很好的理由。ORM通常已经应用了这些规则，例如，每个表都需要有一个id列

如何在TypeForm中定义实体以实现此结果

TypeOrm允许您单方面定义多个关系，但不能反过来定义

@没有@manytone，一个公司就无法生存。如果要使用@OneToMany，则需要@ManyToOne。但是，不需要相反的结果：如果您只关心@manytone关系，那么您可以定义它，而不必在相关实体上使用@OneToMany

这将使：

person.entity.ts

export class Person {
  @Column()
  name: string

  // etc...

  @OneToMany(() => Address, (address) => address.person)
  addresses: Address[]
}

export class Business {
  @Column()
  name: string

  // etc...

  @OneToMany(() => Address, (address) => address.business)
  addresses: Address[]
}

export class Address {
  @Column()
  name: string

  // etc...

  @ManyToOne(() => Person, (p) => p.addresses)
  person: Person

  @ManyToOne(() => Business , (b) => b.addresses)
  business: Business
}

export class Person {
  @Column()
  name: string

  // etc...

  @ManyToMany(() => Address)
  addresses: Address[]
}

export class Business {
  @Column()
  name: string

  // etc...

  @ManyToMany(() => Address)
  addresses: Address[]
}

export class Address {
  @Column()
  name: string

  // etc...
}

business.entity.ts

export class Person {
  @Column()
  name: string

  // etc...

  @OneToMany(() => Address, (address) => address.person)
  addresses: Address[]
}

export class Business {
  @Column()
  name: string

  // etc...

  @OneToMany(() => Address, (address) => address.business)
  addresses: Address[]
}

export class Address {
  @Column()
  name: string

  // etc...

  @ManyToOne(() => Person, (p) => p.addresses)
  person: Person

  @ManyToOne(() => Business , (b) => b.addresses)
  business: Business
}

export class Person {
  @Column()
  name: string

  // etc...

  @ManyToMany(() => Address)
  addresses: Address[]
}

export class Business {
  @Column()
  name: string

  // etc...

  @ManyToMany(() => Address)
  addresses: Address[]
}

export class Address {
  @Column()
  name: string

  // etc...
}

address.entity.ts

export class Person {
  @Column()
  name: string

  // etc...

  @OneToMany(() => Address, (address) => address.person)
  addresses: Address[]
}

export class Business {
  @Column()
  name: string

  // etc...

  @OneToMany(() => Address, (address) => address.business)
  addresses: Address[]
}

export class Address {
  @Column()
  name: string

  // etc...

  @ManyToOne(() => Person, (p) => p.addresses)
  person: Person

  @ManyToOne(() => Business , (b) => b.addresses)
  business: Business
}

export class Person {
  @Column()
  name: string

  // etc...

  @ManyToMany(() => Address)
  addresses: Address[]
}

export class Business {
  @Column()
  name: string

  // etc...

  @ManyToMany(() => Address)
  addresses: Address[]
}

export class Address {
  @Column()
  name: string

  // etc...
}

如果您坚持不在您的地址中包含

多通电话

，您可以通过建立关系来避免这种情况。请记住，这将以更大的查询和更多的表的形式产生一些开销。这是因为多对多将创建一个联接表，需要额外的联接才能从数据库中获取数据。这一切都由orm tho负责

这将使：

person.entity.ts

export class Person {
  @Column()
  name: string

  // etc...

  @OneToMany(() => Address, (address) => address.person)
  addresses: Address[]
}

export class Business {
  @Column()
  name: string

  // etc...

  @OneToMany(() => Address, (address) => address.business)
  addresses: Address[]
}

export class Address {
  @Column()
  name: string

  // etc...

  @ManyToOne(() => Person, (p) => p.addresses)
  person: Person

  @ManyToOne(() => Business , (b) => b.addresses)
  business: Business
}

export class Person {
  @Column()
  name: string

  // etc...

  @ManyToMany(() => Address)
  addresses: Address[]
}

export class Business {
  @Column()
  name: string

  // etc...

  @ManyToMany(() => Address)
  addresses: Address[]
}

export class Address {
  @Column()
  name: string

  // etc...
}

business.entity.ts

export class Person {
  @Column()
  name: string

  // etc...

  @OneToMany(() => Address, (address) => address.person)
  addresses: Address[]
}

export class Business {
  @Column()
  name: string

  // etc...

  @OneToMany(() => Address, (address) => address.business)
  addresses: Address[]
}

export class Address {
  @Column()
  name: string

  // etc...

  @ManyToOne(() => Person, (p) => p.addresses)
  person: Person

  @ManyToOne(() => Business , (b) => b.addresses)
  business: Business
}

export class Person {
  @Column()
  name: string

  // etc...

  @ManyToMany(() => Address)
  addresses: Address[]
}

export class Business {
  @Column()
  name: string

  // etc...

  @ManyToMany(() => Address)
  addresses: Address[]
}

export class Address {
  @Column()
  name: string

  // etc...
}

address.entity.ts

export class Person {
  @Column()
  name: string

  // etc...

  @OneToMany(() => Address, (address) => address.person)
  addresses: Address[]
}

export class Business {
  @Column()
  name: string

  // etc...

  @OneToMany(() => Address, (address) => address.business)
  addresses: Address[]
}

export class Address {
  @Column()
  name: string

  // etc...

  @ManyToOne(() => Person, (p) => p.addresses)
  person: Person

  @ManyToOne(() => Business , (b) => b.addresses)
  business: Business
}

export class Person {
  @Column()
  name: string

  // etc...

  @ManyToMany(() => Address)
  addresses: Address[]
}

export class Business {
  @Column()
  name: string

  // etc...

  @ManyToMany(() => Address)
  addresses: Address[]
}

export class Address {
  @Column()
  name: string

  // etc...
}