在数据库里，表和表之间是存在关系的。

比如用户和身份证是一对一的关系，部门和员工是一对多的关系，文章和标签是多对多的关系。

我们是通过外键来存储这种关系的，多对多的话还要建立中间表。

TypeORM 是把表、字段、表和表的关系映射成 Entity 的 class、属性、Entity 之间的关系，那如何映射这种一对一、一对多、多对多的关系呢？

我们来试一下。

创建 user 和 id_card 表

这次创建个新的 database 来用：

create database typeorm_test;

执行它：

点击刷新，就可以看到这个新的 database 了：

我们用 typeorm 连上它来自动创建表。

npx typeorm@latest init --name typeorm-relation-mapping --database mysql

创建个 typeorm 项目。

修改 DataSource 的配置：

import "reflect-metadata";
import { DataSource } from "typeorm";
import { User } from "./entity/User";

export const AppDataSource = new DataSource({
  type: "mysql",
  host: "localhost",
  port: 3306,
  username: "root",
  password: "guang",
  database: "typeorm_test",
  synchronize: true,
  logging: true,
  entities: [User],
  migrations: [],
  subscribers: [],
  poolSize: 10,
  connectorPackage: "mysql2",
  extra: {
    authPlugin: "sha256_password",
  },
});

安装驱动包 mysql2

npm install --save mysql2

然后跑起来：

npm run start

可以看到，它生成了建表 sql 和插入数据的 sql：

点击刷新，在 workbench 里也可以看到这个新建的表：

点击新建 sql，执行 select，也是可以看到插入的数据的：

然后我们再创建个身份证表。

通过 typeorm entity:create 命令创建：

npx typeorm entity:create src/entity/IdCard

填入属性和映射信息：

import { Column, Entity, PrimaryGeneratedColumn } from "typeorm";

@Entity({
  name: "id_card",
})
export class IdCard {
  @PrimaryGeneratedColumn()
  id: number;

  @Column({
    length: 50,
    comment: "身份证号",
  })
  cardName: string;
}

在 DataSource 的 entities 里引入下：

重新 npm run start：

可以看到生成了这条建表 sql。

workbench 里也可以看到这个表：

现在 user 和 id_card 表都有了，怎么让它们建立一对一的关联呢？

先把这两个表删除：

drop table id_card,user;

在 IdCard 的 Entity 添加一个 user 列，指定它和 User 是 @OneToTone 一对一的关系。

还要指定 @JoinColum 也就是外键列在 IdCard 对应的表里维护：

重新 npm run start：

仔细看生成的这 3 条 sql 语句。

前两个是建表 sql，创建 id_card 和 user 表。

最后一个是给修改 id_card 表，给 user_id 列添加一个外建约束，引用 user 表的 id 列。

在 workbench 里看下：

生成的表都是对的。

但是这个级联关系还是默认的：

如果我们想设置 CASCADE 应该怎么做呢？

在第二个参数指定：

删除这两个表：

drop table id_card,user;

重新 npm run start：

这样就设置了级联删除和级联更新。

我们再来试下增删改查：

import { AppDataSource } from "./data-source";
import { IdCard } from "./entity/IdCard";
import { User } from "./entity/User";

AppDataSource.initialize()
  .then(async () => {
    const user = new User();
    user.firstName = "guang";
    user.lastName = "guang";
    user.age = 20;

    const idCard = new IdCard();
    idCard.cardName = "1111111";
    idCard.user = user;

    await AppDataSource.manager.save(user);
    await AppDataSource.manager.save(idCard);
  })
  .catch((error) => console.log(error));

创建 user 和 idCard 对象，设置 idCard.user 为 user，也就是建立关联。

然后先保存 user，再保存 idCard。

跑 npm run start，生成的 sql 如下：

可以看到后面插入 id_card 的时候，已经有 userId 可以填入了。

数据都插入成功了：

但是我还要分别保存 user 和 idCard，能不能自动按照关联关系来保存呢？

可以的，在 @OneToOne 那里指定 cascade 为 true：

这个 cascade 不是数据库的那个级联，而是告诉 typeorm 当你增删改一个 Entity 的时候，是否级联增删改它关联的 Entity。

这样我们就不用自己保存 user 了：

重新 npm run start：

可以看到它同样是先插入了 user，再插入了 id_card，并且设置了正确的 userId。

保存了之后，怎么查出来呢？

我们用 find 来试下：

const ics = await AppDataSource.manager.find(IdCard);
console.log(ics);

跑下 npm run start：

可以看到 idCard 查出来了，但是关联的 user 没查出来。

只需要声明下 relations 关联查询就好了：

const ics = await AppDataSource.manager.find(IdCard, {
  relations: {
    user: true,
  },
});
console.log(ics);

再跑一下：

现在 idCard 关联的 user 就被查出来了。

当然，你也可以用 query builder 的方式来查询：

const ics = await AppDataSource.manager
  .getRepository(IdCard)
  .createQueryBuilder("ic")
  .leftJoinAndSelect("ic.user", "u")
  .getMany();

console.log(ics);

先 getRepository 拿到操作 IdCard 的 Repository 对象。

再创建 queryBuilder 来连接查询，给 idCard 起个别名 ic，然后连接的是 ic.user，起个别名为 u：

或者也可以直接用 EntityManager 创建 queryBuilder 来连接查询：

const ics = await AppDataSource.manager
  .createQueryBuilder(IdCard, "ic")
  .leftJoinAndSelect("ic.user", "u")
  .getMany();
console.log(ics);

再来试下修改：

现在数据是这样的：

我们给它加上 id 再 save：

const user = new User();
user.id = 1;
user.firstName = "guang1111";
user.lastName = "guang1111";
user.age = 20;

const idCard = new IdCard();
idCard.id = 1;
idCard.cardName = "22222";
idCard.user = user;

await AppDataSource.manager.save(idCard);

这样数据就被修改了：

看下生成的 sql：

在一个事务内，执行了两条 update 的 sql。

最后再试试删除。

因为设置了外键的 onDelete 是 cascade，所以只要删除了 user，那关联的 idCard 就会跟着被删除。

await AppDataSource.manager.delete(User, 1);

如果不是没有这种级联删除，就需要手动删了：

const idCard = await AppDataSource.manager.findOne(IdCard, {
  where: {
    id: 1,
  },
  relations: {
    user: true,
  },
});
await AppDataSource.manager.delete(User, idCard.user.id);
await AppDataSource.manager.delete(IdCard, idCard.id);

不过现在我们只是在 idCard 里访问 user，如果想在 user 里访问 idCard 呢？

同样需要加一个 @OneToOne 的装饰器：

不过需要有第二个参数。

因为如果是维持外键的那个表，也就是有 @JoinColumn 的那个 Entity，它是可以根据外键关联查到另一方的。

但是没有外键的表怎么查到另一方呢？

所以这里通过第二个参数告诉 typeorm，外键是另一个 Entity 的哪个属性。

我们查一下试试：

const user = await AppDataSource.manager.find(User, {
  relations: {
    idCard: true,
  },
});
console.log(user);

可以看到，同样关联查询成功了：

这就是一对一关系的映射和增删改查。

案例代码在小册仓库 (opens new window)。

总结

TypeORM 里一对一关系的映射通过 @OneToOne 装饰器来声明，维持外键列的 Entity 添加 @JoinColumn 装饰器。

如果是非外键列的 Entity，想要关联查询另一个 Entity，则需要通过第二个参数指定外键列是另一个 Entity 的哪个属性。

可以通过 @OneToOne 装饰器的 onDelete、onUpdate 参数设置级联删除和更新的方式，比如 CASCADE、SET NULL 等。

还可以设置 cascade，也就是 save 的时候会自动级联相关 Entity 的 save。

增删改分别通过 save 和 delete 方法，查询可以通过 find 也可以通过 queryBuilder，不过要 find 的时候要指定 relations 才会关联查询。

这就是 TypeORM 里一对一的映射和增删改查，下节我们继续学习一对多的映射。