TypeORM
TypeORM 是一个用于 Node.js 和 TypeScript 的对象关系映射(ORM)框架。ORM 框架用于简化数据库操作,允许开发人员使用面向对象的方式来管理数据库模型和执行数据库查询。
TypeORM 提供了许多功能,包括:
- 对象关系映射:TypeORM 提供了实体(Entity)和数据库表之间的映射,使开发人员可以使用类和对象来表示和操作数据库表和记录。
- 数据库支持:TypeORM 支持多种数据库系统,包括 MySQL、PostgreSQL、SQLite、Microsoft SQL Server 等。
- 数据库迁移:TypeORM 具备数据库迁移功能,可以轻松地对数据库模式进行版本控制和迁移,方便管理数据库的变更。
- 查询语言:TypeORM 提供了强大的查询构建器和查询语言,使开发人员能够以编程方式构建复杂的数据库查询,并支持链式调用和灵活的查询条件。
- 关联和关系:TypeORM 支持定义实体之间的关联关系,如一对一、一对多和多对多关系,使开发人员能够轻松地处理实体之间的关联查询和操作。
- 事务支持:TypeORM 具备事务管理功能,可以确保一系列数据库操作的原子性和一致性。
- 支持 TypeScript:TypeORM 是为 TypeScript 设计的,可以充分利用 TypeScript 的类型系统以及其他高级语言特性。
TypeORM 的目标是提供一个简单、灵活和强大的 ORM 解决方案,帮助开发人员更轻松地与数据库交互,并提供高效、可维护的数据库操作代码。它广泛应用于 Node.js 和 TypeScript 的后端开发中,并受到社区的积极支持和贡献。
下文示例相关仓库:https://github.com/qiuxchao/typeorm-demo
安装 & 创建项目
开始使用 TypeORM 的最快方法是使用其 CLI 命令生成启动项目。
首先全局安装 TypeORM:
npm install typeorm -g
然后转到要创建新项目的目录并运行命令:
typeorm init --name MyProject --database mysql
其中 name
是项目的名称,database
是您将使用的数据库。
数据库可以是以下值之一: mysql
, mariadb
, postgres
, sqlite
, mssql
, oracle
, mongodb
, cordova
, react-native
, expo
, nativescript
.
此命令将在 MyProject
目录中生成一个包含以下文件的新项目:
MyProject
├── src // TypeScript 代码
│ ├── entity // 存储实体(数据库模型)的位置
│ │ └── User.ts // 示例 entity
│ ├── migration // 存储迁移的目录
│ ├── data-source.ts // ORM和数据库连接配置
│ └── index.ts // 程序执行主文件
├── .gitignore // gitignore文件
├── package.json // node module 依赖
├── README.md // 简单的 readme 文件
└── tsconfig.json // TypeScript 编译选项
你还可以在现有 node 项目上运行typeorm init,但要注意,此操作可能会覆盖已有的某些文件。
接下来安装项目依赖项:
cd MyProject
npm install
在安装过程中,编辑 data-source.ts
文件并在其中放置您自己的数据库连接配置选项:
export const AppDataSource = new DataSource({
type: 'mysql',
host: 'localhost',
port: 3306,
username: 'test',
password: 'test',
database: 'test',
synchronize: true,
logging: false,
entities: [`${__dirname}/entity/*.ts`],
migrations: [],
subscribers: [],
});
绝大多数情况下,你只需要配置 host
, username
, password
, database
或者 port
。
完成配置并安装所有 node modules 后,即可运行应用程序:
npm run start
至此你的应用程序应该成功运行并将新用户插入数据库。你可以继续使用此项目并集成所需的其他模块并创建更多实体。
你可以通过运行
typeorm init --name MyProject --database mysql --express
来生成一个更高级的 Express 项目
分步指南
您对 ORM 有何期待?您期望它将为您创建数据库表,并且无需编写大量难以维护的 SQL 语句来查找/插入/更新/删除您的数据。本指南将向您展示如何从头开始设置 TypeORM 并实现这些操作。
创建一个模型
使用数据库从创建表开始。如何告诉 TypeORM 创建数据库表?答案是 - 通过模型。 应用程序中的模型即是数据库中的表。
举个例子, 你有一个 Photo
模型:
export class Photo {
id: number;
name: string;
description: string;
filename: string;
views: number;
}
并且希望将 photos 存储在数据库中。要在数据库中存储内容,首先需要一个数据库表,并从模型中创建数据库表。但是并非所有模型,只有您定义为 entities 的模型。
创建一个实体
Entity 是由 @Entity
装饰器装饰的模型。将为此类模型创建数据库表。你可以使用 TypeORM 处理各处的实体,可以使用它们 load/insert/update/remove 并执行其他操作。
让我们将 Photo
模型作为一个实体
import { Entity } from "typeorm";
@Entity()
export class Photo {
id: number;
name: string;
description: string;
filename: string;
views: number;
isPublished: boolean;
}
现在,将为 Photo
实体创建一个数据库表,我们将能够在应用程序中的任何位置使用它。 我们已经创建了一个数据库表,但是没有哪个字段属于哪一列,下面让我们在数据库表中创建几列。
添加表列
要添加数据库列,你只需要将要生成的实体属性加上 @Column
装饰器。
import { Entity, Column } from "typeorm";
@Entity()
export class Photo {
@Column()
id: number;
@Column()
name: string;
@Column()
description: string;
@Column()
filename: string;
@Column()
views: number;
@Column()
isPublished: boolean;
}
现在 id
, name
, description
, filename
, views
和 isPublished
列将会被添加到 photo
表中。 数据库中的列类型是根据你使用的属性类型推断的,例如: number
将被转换为 integer
,string
将转换为 varchar
,boolean
转换为 bool
等。但你也可以通过在 @Column
装饰器中隐式指定列类型来使用数据库支持的任何列类型。
我们已经生成了一个包含列的数据库表,但还剩下一件事。每个数据库表必须具有包含主键的列。
创建主列
每个实体必须至少有一个主键列。这是必须的,你无法避免。要使列成为主键,您需要使用 @PrimaryColumn
装饰器。
import { Entity, Column, PrimaryColumn } from "typeorm";
@Entity()
export class Photo {
@PrimaryColumn()
id: number;
@Column()
name: string;
@Column()
description: string;
@Column()
filename: string;
@Column()
views: number;
@Column()
isPublished: boolean;
}
创建自动生成的列
假设你希望 id 列自动生成(这称为 auto-increment/sequence/serial/generated identity column)。为此你需要将 @PrimaryColumn
装饰器更改为 @PrimaryGeneratedColumn
装饰器:
import { Entity, Column, PrimaryGeneratedColumn } from "typeorm";
@Entity()
export class Photo {
@PrimaryGeneratedColumn()
id: number;
@Column()
name: string;
@Column()
description: string;
@Column()
filename: string;
@Column()
views: number;
@Column()
isPublished: boolean;
}
列数据类型
接下来,让我们修复数据类型。默认情况下,字符串被映射到一个 varchar(255)类型(取决于数据库类型)。 数字被映射到一个类似整数类型(取决于数据库类型)。但是我们不希望所有的列都是有限的 varchars 或整数,让我们修改下代码以设置想要的数据类型:
import { Entity, Column, PrimaryGeneratedColumn } from "typeorm";
@Entity()
export class Photo {
@PrimaryGeneratedColumn()
id: number;
@Column({
length: 100
})
name: string;
@Column("text")
description: string;
@Column()
filename: string;
@Column("double")
views: number;
@Column()
isPublished: boolean;
}
列类型是特定于数据库的。你可以设置数据库支持的任何列类型。有关支持的列类型的更多信息,请参见此处。
创建数据库的连接
当实体被创建后,让我们创建一个 index.ts
(或 app.ts
,无论你怎么命名)文件,并配置数据库连接:
import "reflect-metadata";
import { createConnection } from "typeorm";
import { Photo } from "./entity/Photo";
createConnection({
type: "mysql",
host: "localhost",
port: 3306,
username: "root",
password: "admin",
database: "test",
entities: [Photo],
synchronize: true,
logging: false
})
.then(connection => {
// 这里可以写实体操作相关的代码
})
.catch(error => console.log(error));
我们在此示例中使用 MySQL,你可以使用任何其他受支持的数据库。要使用其他数据库,只需将选项中的type更改为希望使用的数据库类型:mysql,mariadb,postgres,sqlite,mssql,oracle,cordova,nativescript,react-native,expo 或 mongodb。同时还要确保 host
, port
, username
, password
和数据库设置的正确性。
我们将 Photo
实体添加到此连接的实体列表中。所有需要在连接中使用的每个实体都必须加到这个表中。
设置 synchronize
可确保每次运行应用程序时实体都将与数据库同步。
加载目录中所有实体
之后当我们创建更多实体时,都需要将一一它们添加到配置中的实体中,但是这不是很方便,所以我们可以设置整个目录,从中连接所有实体并在连接中使用:
import { createConnection } from "typeorm";
createConnection({
type: "mysql",
host: "localhost",
port: 3306,
username: "root",
password: "admin",
database: "test",
entities: [__dirname + "/entity/*.ts"],
synchronize: true
})
.then(connection => {
// 这里可以写实体操作相关的代码
})
.catch(error => console.log(error));
但要小心这种方法。 如果使用的是 ts-node
,则需要指定 .ts
文件的路径。 如果使用的是 outDir
,那么需要在 outDir
目录中指定 .js
文件的路径。 如果使用 outDir
,当你删除或重命名实体时,请确保清除 outDir
目录并再次重新编译项目,因为当你删除 .ts
源文件时,其编译的 .js
版本不会从输出目录中删除,并且 TypeORM 依然会从 outDir
中加载这些文件,从而导致异常。
启动应用
现在可以启动 app.ts
,启动后可以发现数据库自动被初始化,并且 Photo
这个表也会创建出来。
+-------------+--------------+----------------------------+
| photo |
+-------------+--------------+----------------------------+
| id | int(11) | PRIMARY KEY AUTO_INCREMENT |
| name | varchar(500) | |
| description | text | |
| filename | varchar(255) | |
| views | int(11) | |
| isPublished | boolean | |
+-------------+--------------+----------------------------+
添加和插入 photo
现在创建一个新的 photo 存到数据库:
import { createConnection } from "typeorm";
import { Photo } from "./entity/Photo";
createConnection(/*...*/)
.then(connection => {
let photo = new Photo();
photo.name = "Me and Bears";
photo.description = "I am near polar bears";
photo.filename = "photo-with-bears.jpg";
photo.views = 1;
photo.isPublished = true;
return connection.manager.save(photo).then(photo => {
console.log("Photo has been saved. Photo id is", photo.id);
});
})
.catch(error => console.log(error));
保存实体后,它将获得新生成的 ID。 save
方法返回传递给它的同一对象的实例。但它不是对象的新副本,只是修改了它的"id"并返回它。
使用 async/await 语法
我们可以使用最新的 ES8(ES2017)功能,并使用 async
/ await
语法代替:
import { createConnection } from "typeorm";
import { Photo } from "./entity/Photo";
createConnection(/*...*/)
.then(async connection => {
let photo = new Photo();
photo.name = "Me and Bears";
photo.description = "I am near polar bears";
photo.filename = "photo-with-bears.jpg";
photo.views = 1;
photo.isPublished = true;
await connection.manager.save(photo);
console.log("Photo has been saved");
})
.catch(error => console.log(error));
使用 Entity Manager
我们刚创建了一张新 photo 并将其保存在数据库中。使用 EntityManager
你可以操纵应用中的任何实体。
例如,加载已经保存的实体:
import { createConnection } from "typeorm";
import { Photo } from "./entity/Photo";
createConnection(/*...*/)
.then(async connection => {
/*...*/
let savedPhotos = await connection.manager.find(Photo);
console.log("All photos from the db: ", savedPhotos);
})
.catch(error => console.log(error));
savedPhotos
是一个 Photo
对象数组,其中包含从数据库加载的数据。
了解更多有关 EntityManager
的信息。
使用 Repositories
现在让我们重构之前的代码,并使用 Repository
而不是 EntityManager
。每个实体都有自己的存储库,可以处理其实体的所有操作。当你经常处理实体时,Repositories
比 EntityManagers
更方便使用:
import { createConnection } from "typeorm";
import { Photo } from "./entity/Photo";
createConnection(/*...*/)
.then(async connection => {
let photo = new Photo();
photo.name = "Me and Bears";
photo.description = "I am near polar bears";
photo.filename = "photo-with-bears.jpg";
photo.views = 1;
photo.isPublished = true;
let photoRepository = connection.getRepository(Photo);
await photoRepository.save(photo);
console.log("Photo has been saved");
let savedPhotos = await photoRepository.find();
console.log("All photos from the db: ", savedPhotos);
})
.catch(error => console.log(error));
了解更多有关 Repository 的信息。
从数据库加载
让我们使用 Repository
尝试更多的加载操作:
import { createConnection } from "typeorm";
import { Photo } from "./entity/Photo";
createConnection(/*...*/)
.then(async connection => {
/*...*/
let allPhotos = await photoRepository.find();
console.log("All photos from the db: ", allPhotos);
let firstPhoto = await photoRepository.findOne({ where: {} });
console.log("First photo from the db: ", firstPhoto);
let meAndBearsPhoto = await photoRepository.findOne({ where: { name: "Me and Bears" } });
console.log("Me and Bears photo from the db: ", meAndBearsPhoto);
let allViewedPhotos = await photoRepository.find({ views: 1 });
console.log("All viewed photos: ", allViewedPhotos);
let allPublishedPhotos = await photoRepository.find({ isPublished: true });
console.log("All published photos: ", allPublishedPhotos);
let [allPhotos, photosCount] = await photoRepository.findAndCount();
console.log("All photos: ", allPhotos);
console.log("Photos count: ", photosCount);
})
.catch(error => console.log(error));
在数据库中更新
让我们从数据库加载出 photo,更新并保存到数据库:
import { createConnection } from "typeorm";
import { Photo } from "./entity/Photo";
createConnection(/*...*/)
.then(async connection => {
/*...*/
let photoToUpdate = await photoRepository.findOne({ where: {} });
photoToUpdate.name = "Me, my friends and polar bears";
await photoRepository.save(photoToUpdate);
})
.catch(error => console.log(error));
这个 id = 1
的 photo 在数据库中就成功更新了。
从数据库中删除
让我们从数据库中删除我们的 Photo:
import { createConnection } from "typeorm";
import { Photo } from "./entity/Photo";
createConnection(/*...*/)
.then(async connection => {
/*...*/
let photoToRemove = await photoRepository.findOne({ where: {} });
await photoRepository.remove(photoToRemove);
})
.catch(error => console.log(error));
这个 id = 1
的 photo 在数据库中被移除了。
创建一对一的关系
让我们与另一个类创建一对一的关系。先在 PhotoMetadata.ts
中创建一个新类。此 PhotoMetadata 类应包含 photo 的其他元信息:
import { Entity, Column, PrimaryGeneratedColumn, OneToOne, JoinColumn } from "typeorm";
import { Photo } from "./Photo";
@Entity()
export class PhotoMetadata {
@PrimaryGeneratedColumn()
id: number;
@Column("int")
height: number;
@Column("int")
width: number;
@Column()
orientation: string;
@Column()
compressed: boolean;
@Column()
comment: string;
@OneToOne(type => Photo)
@JoinColumn()
photo: Photo;
}
这里我们使用了一个名为 @OneToOne
的新装饰器,它允许我们在两个实体之间创建一对一的关系。 type => Photo
是一个函数,返回我们想要与之建立关系的实体的类。由于特定于语言的关系,我们只能使用一个返回类的函数,而不是直接使用该类。 同时也可以把它写成 ()=> Photo
,但是 type => Photo
显得代码更有可读性。type
变量本身不包含任何内容。
我们还添加了一个 @JoinColumn
装饰器,表明实体键的对应关系。关系可以是单向的或双向的。但是只有一方是拥有者。在关系的所有者方面需要使用 @JoinColumn
装饰器。
如果运行该应用程序,你将看到一个新生成的表,它将包含一个带有关系外键的列:
+-------------+--------------+----------------------------+
| photo_metadata |
+-------------+--------------+----------------------------+
| id | int(11) | PRIMARY KEY AUTO_INCREMENT |
| height | int(11) | |
| width | int(11) | |
| comment | varchar(255) | |
| compressed | boolean | |
| orientation | varchar(255) | |
| photoId | int(11) | FOREIGN KEY |
+-------------+--------------+----------------------------+
保存一对一的关系
现在来创建一个 photo,它的元信息将它们互相连接起来。
import { createConnection } from "typeorm";
import { Photo } from "./entity/Photo";
import { PhotoMetadata } from "./entity/PhotoMetadata";
createConnection(/*...*/)
.then(async connection => {
// 创建 photo
let photo = new Photo();
photo.name = "Me and Bears";
photo.description = "I am near polar bears";
photo.filename = "photo-with-bears.jpg";
photo.isPublished = true;
// 创建 photo metadata
let metadata = new PhotoMetadata();
metadata.height = 640;
metadata.width = 480;
metadata.compressed = true;
metadata.comment = "cybershoot";
metadata.orientation = "portait";
metadata.photo = photo; // 联接两者
// 获取实体 repositories
let photoRepository = connection.getRepository(Photo);
let metadataRepository = connection.getRepository(PhotoMetadata);
// 先保存photo
await photoRepository.save(photo);
// 然后保存photo的metadata
await metadataRepository.save(metadata);
// 完成
console.log("Metadata is saved, and relation between metadata and photo is created in the database too");
})
.catch(error => console.log(error));
反向关系
关系可以是单向的或双向的。目前 PhotoMetadata 和 Photo 之间的关系是单向的。关系的所有者是 PhotoMetadata,而 Photo 对 PhotoMetadata 一无所知。这使得从 Photo 中访问 PhotoMetadata 变得很复杂。要解决这个问题,我们应该在 PhotoMetadata 和 Photo 之间建立双向关系。让我们来修改一下实体:
import { Entity, Column, PrimaryGeneratedColumn, OneToOne, JoinColumn } from "typeorm";
import { Photo } from "./Photo";
@Entity()
export class PhotoMetadata {
/* ... other columns */
@OneToOne(type => Photo, photo => photo.metadata)
@JoinColumn()
photo: Photo;
}
import { Entity, Column, PrimaryGeneratedColumn, OneToOne } from "typeorm";
import { PhotoMetadata } from "./PhotoMetadata";
@Entity()
export class Photo {
/* ... other columns */
@OneToOne(type => PhotoMetadata, photoMetadata => photoMetadata.photo)
metadata: PhotoMetadata;
}
photo => photo.metadata
是用来指定反向关系的名称。Photo 类的元数据属性是在 Photo 类中存储 PhotoMetadata 的地方。你可以选择简单地将字符串传递给 @OneToOne
装饰器,而不是传递返回 photo 属性的函数,例如 "metadata"
。这种函数类型的方法使我们的重构更容易。
注意,我们应该仅在关系的一侧使用 @JoinColumn
装饰器。你把这个装饰者放在哪一方将是这段关系的拥有方。关系的拥有方包含数据库中具有外键的列。
取出关系对象的数据
在一个查询中加载 photo 及 photo metadata 有两种方法。使用 find *
或使用 QueryBuilder
。我们先使用 find *
方法。 find *
方法允许你使用 FindOneOptions
/ FindManyOptions
接口指定对象。
import { createConnection } from "typeorm";
import { Photo } from "./entity/Photo";
import { PhotoMetadata } from "./entity/PhotoMetadata";
createConnection(/*...*/)
.then(async connection => {
/*...*/
let photoRepository = connection.getRepository(Photo);
let photos = await photoRepository.find({ relations: ["metadata"] });
})
.catch(error => console.log(error));
photos 将包含来自数据库的 photos 数组,每个 photo 将包含其 photo metadata。详细了解本文档中的查找选项。
使用查找选项很简单,但是如果你需要更复杂的查询,则应该使用 QueryBuilder
。 QueryBuilder
允许以更优雅的方式使用更复杂的查询:
import { createConnection } from "typeorm";
import { Photo } from "./entity/Photo";
import { PhotoMetadata } from "./entity/PhotoMetadata";
createConnection(/*...*/)
.then(async connection => {
/*...*/
let photos = await connection
.getRepository(Photo)
.createQueryBuilder("photo")
.innerJoinAndSelect("photo.metadata", "metadata")
.getMany();
})
.catch(error => console.log(error));
QueryBuilder
允许创建和执行几乎任何复杂性的 SQL 查询。使用 QueryBuilder
时,请考虑创建 SQL 查询。在此示例中,"photo"和"metadata"是应用于所选 photos 的 别名。你可以使用别名来访问所选数据的列和属性。
使用 cascades 自动保存相关对象
我们可以在关系中设置 cascade
选项,这是就可以在保存其他对象的同时保存相关对象。让我们更改一下的 photo 的 @OneToOne
装饰器:
export class Photo {
/// ... other columns
@OneToOne(type => PhotoMetadata, metadata => metadata.photo, {
cascade: true
})
metadata: PhotoMetadata;
}
使用 cascade
就不需要边存 photo 边存元数据对象。我们可以简单地保存一个 photo 对象,由于使用了 cascade,metadata 也将自动保存。
createConnection(options)
.then(async connection => {
// 创建 photo 对象
let photo = new Photo();
photo.name = "Me and Bears";
photo.description = "I am near polar bears";
photo.filename = "photo-with-bears.jpg";
photo.isPublished = true;
// 创建 photo metadata 对象
let metadata = new PhotoMetadata();
metadata.height = 640;
metadata.width = 480;
metadata.compressed = true;
metadata.comment = "cybershoot";
metadata.orientation = "portait";
photo.metadata = metadata; // this way we connect them
// 获取 repository
let photoRepository = connection.getRepository(Photo);
// 保存photo的同时保存metadata
await photoRepository.save(photo);
console.log("Photo is saved, photo metadata is saved too.");
})
.catch(error => console.log(error));
创建多对一/一对多关系
让我们创建一个多对一/一对多的关系。假设一个 photo 有一个 author,每个 author 都可以有多个 photos。首先让我们创建一个Author
类:
import { Entity, Column, PrimaryGeneratedColumn, OneToMany, JoinColumn } from "typeorm";
import { Photo } from "./Photo";
@Entity()
export class Author {
@PrimaryGeneratedColumn()
id: number;
@Column()
name: string;
@OneToMany(type => Photo, photo => photo.author) // note: we will create author property in the Photo class below
photos: Photo[];
}
Author
包含反向关系。 OneToMany
总是反向的, 并且总是与 ManyToOne
一起出现。
现在让我们将关系的所有者方添加到 Photo 实体中:
import { Entity, Column, PrimaryGeneratedColumn, ManyToOne } from "typeorm";
import { PhotoMetadata } from "./PhotoMetadata";
import { Author } from "./Author";
@Entity()
export class Photo {
/* ... other columns */
@ManyToOne(type => Author, author => author.photos)
author: Author;
}
在多对一/一对多的关系中,拥有方总是多对一的。这意味着使用 @ManyToOne
的类将存储相关对象的 id。 运行应用程序后,ORM 将创建 author
表:
+-------------+--------------+----------------------------+
| photo |
+-------------+--------------+----------------------------+
| id | int(11) | PRIMARY KEY AUTO_INCREMENT |
| name | varchar(255) | |
| description | varchar(255) | |
| filename | varchar(255) | |
| isPublished | boolean | |
| authorId | int(11) | FOREIGN KEY |
+-------------+--------------+----------------------------+
创建多对多关系
假设一个 photo 可以放在多个 albums 中,每个 albums 可以包含多个 photo。让我们创建一个 Album
类:
import { Entity, PrimaryGeneratedColumn, Column, ManyToMany, JoinTable } from "typeorm";
@Entity()
export class Album {
@PrimaryGeneratedColumn()
id: number;
@Column()
name: string;
@ManyToMany(type => Photo, photo => photo.albums)
@JoinTable()
photos: Photo[];
}
@JoinTable
需要指定这是关系的所有者方。
现在添加反向关系到 Photo
类:
export class Photo {
/// ... other columns
@ManyToMany(type => Album, album => album.photos)
albums: Album[];
}
运行后,ORM 将创建 album_photos_photo
联结表。
+-------------+--------------+----------------------------+
| album_photos_photo |
+-------------+--------------+----------------------------+
| album_id | int(11) | PRIMARY KEY FOREIGN KEY |
| photo_id | int(11) | PRIMARY KEY FOREIGN KEY |
+-------------+--------------+----------------------------+
现在让我们将 albums 和 photos 插入我们的数据库:
let connection = await createConnection(options);
// create a few albums
let album1 = new Album();
album1.name = "Bears";
await connection.manager.save(album1);
let album2 = new Album();
album2.name = "Me";
await connection.manager.save(album2);
// create a few photos
let photo = new Photo();
photo.name = "Me and Bears";
photo.description = "I am near polar bears";
photo.filename = "photo-with-bears.jpg";
photo.albums = [album1, album2];
await connection.manager.save(photo);
// now our photo is saved and albums are attached to it
// now lets load them:
const loadedPhoto = await connection.getRepository(Photo).findOne({ where: {}, relations: ["albums"] });
loadedPhoto
如下所示:
{
id: 1,
name: "Me and Bears",
description: "I am near polar bears",
filename: "photo-with-bears.jpg",
albums: [{
id: 1,
name: "Bears"
}, {
id: 2,
name: "Me"
}]
}
使用 QueryBuilder
你可以使用 QueryBuilder
构建几乎任何复杂性的 SQL 查询。例如,可以这样做:
let photos = await connection
.getRepository(Photo)
.createQueryBuilder("photo") // first argument is an alias. Alias is what you are selecting - photos. You must specify it.
.innerJoinAndSelect("photo.metadata", "metadata")
.leftJoinAndSelect("photo.albums", "album")
.where("photo.isPublished = true")
.andWhere("(photo.name = :photoName OR photo.name = :bearName)")
.orderBy("photo.id", "DESC")
.skip(5)
.take(10)
.setParameters({ photoName: "My", bearName: "Mishka" })
.getMany();
此查询选择所有 published
的 name
等于 "My"
或 "Mishka"
的 photos。它将从结果中的第 5 个(分页偏移)开始,并且仅选择 10 个结果(分页限制)。得到的结果将按 ID 降序排序。photo 的 albums 将被 left-joined,其元数据将被 inner joined。
由于 QueryBuilder
的自由度更高,因此在项目中可能会大量的使用它。 更多关于 QueryBuilder
的信息,可查看。