查看: 835|回复: 0

[DIV/CSS] Nodejs最好的ORM - TypeORM

发表于 2017-7-22 08:00:02

TypeORM github: https://github.com/typeorm/typeorm

这篇译文是从TypeORM github上的使用说明上翻译过来的,已经提交PR并merge到库中了。

TypeORM是一个采用TypeScript编写的用于Node.js的优秀ORM框架,支持使用TypeScript或Javascript(ES5, ES6, ES7)开发。

目标是保持支持最新的Javascript特性来帮助开发各种用到数据库的应用 - 不管是轻应用还是企业级的。

TypeORM可以做到:

根据Models自动创建数据库Table 可以透明的insert/update/delete数据库对象 映射数据库table到javascript对象,映射table column到javascript对象属性 提供表的一对一,多对一,一对多,多对多关系处理 还有更多 ...

不同于其他的JavaScript ORM,TypeORM使用的是数据映射模式,可以很轻松的创建出松耦合、可伸缩、可维护的应用。

TypeORM可以帮助开发者专注于业务逻辑,而不用过于担心数据存储的问题。

TypeORM参考了很多其他优秀ORM的实现, 比如 Hibernate , Doctrine 和 Entity Framework .

安装

安装TypeORM:

npm install typeorm --save

需要安装依赖模块 reflect-metadata :

npm install reflect-metadata --save

在应用里全局引用一下:

比如在app.ts的入口处 require("reflect-metadata")

安装数据库驱动:

MySQL或 MariaDB

npm install mysql --save

Postgres

npm install pg --save

SQLite

npm install sqlite3 --save

Microsoft SQL Server

npm install mssql --save

Oracle(experimental)

npm install oracledb --save

可以根据你的数据库选择安装上面的任意一个.

使用oracle驱动需要参考安装说明: 地址 .

TypeScript配置

确保你的TypeScript编译器的版本大于 2.1 ,并且在 tsconfig.json 开启下面设置:

  1. "emitDecoratorMetadata": true,
  2. "experimentalDecorators": true,
复制代码

同时需要开启编译选项里的 lib 下的 es6 或者从 @typings 安装 es6-shim

Node.js 版本

TypeORM在Node.JS 4.0或以上版本上测试通过。

如果在应用启动过程中出错可以尝试升级node.js到最新版本。

在浏览器中使用WebSQL (试用)

TypeORM可以在浏览器环境中工作,并且试验性的支持WebSQL

如果在浏览器环境中使用TypeORM需要使用 npm i typeorm-browser 来替代 typeorm .

快速开始

在TypeORM中,数据库table都是从实体中创建。

所谓 实体 其实就是用装饰器 @Table 装饰的一个model。

可以直接从数据库中得到包含数据的实体对象,并且可以通过实体进行数据库表的insert/update/remove。

来看看这个model entity/Photo.ts :

  1. export class Photo {
  2. id: number;
  3. name: string;
  4. description: string;
  5. fileName: string;
  6. views: number;
  7. }
复制代码
创建实体

现在把Model变成实体:

  1. import {Table} from "typeorm";
  2. @Table()
  3. export class Photo {
  4. id: number;
  5. name: string;
  6. description: string;
  7. fileName: string;
  8. views: number;
  9. isPublished: boolean;
  10. }
复制代码
添加table列

已经有了一个table,每个table都有column.

现在来添加列.

可以使用装饰器 @Column 来把model的属性变成列:

  1. import {Table, Column} from "typeorm";
  2. @Table()
  3. export class Photo {
  4. @Column()
  5. id: number;
  6. @Column()
  7. name: string;
  8. @Column()
  9. description: string;
  10. @Column()
  11. fileName: string;
  12. @Column()
  13. views: number;
  14. @Column()
  15. isPublished: boolean;
  16. }
复制代码
创建一个主键列

很好, 现在ORM马上就可以在数据库中生成这个photo表,不过还漏了一个,每个table都必须要有主键列,所以要加上它。

可以用 @PrimaryColumn 装饰器来标记一个主键列。

  1. import {Table, Column, PrimaryColumn} from "typeorm";
  2. @Table()
  3. export class Photo {
  4. @PrimaryColumn()
  5. id: number;
  6. @Column()
  7. name: string;
  8. @Column()
  9. description: string;
  10. @Column()
  11. fileName: string;
  12. @Column()
  13. views: number;
  14. @Column()
  15. isPublished: boolean;
  16. }
复制代码
创建自增长/自生成/顺序化的列

如果你想创建自增长/自生成/顺序化的列,需要把column的type改成integer并且给主键列加上一个属性 { generated: true }

  1. import {Table, Column, PrimaryColumn} from "typeorm";
  2. @Table()
  3. export class Photo {
  4. @PrimaryColumn("int", { generated: true })
  5. id: number;
  6. @Column()
  7. name: string;
  8. @Column()
  9. description: string;
  10. @Column()
  11. fileName: string;
  12. @Column()
  13. views: number;
  14. @Column()
  15. isPublished: boolean;
  16. }
复制代码
使用 @PrimaryGeneratedColumn 装饰器

现在photo表的id可能自动生成自动增长,不过还是有点麻烦,这个一个很常见的功能,所以有一个专门的装饰器 @PrimaryGeneratedColumn 来实现相同的功能。

  1. import {Table, Column, PrimaryGeneratedColumn} from "typeorm";
  2. @Table()
  3. export class Photo {
  4. @PrimaryGeneratedColumn()
  5. id: number;
  6. @Column()
  7. name: string;
  8. @Column()
  9. description: string;
  10. @Column()
  11. fileName: string;
  12. @Column()
  13. views: number;
  14. @Column()
  15. isPublished: boolean;
  16. }
复制代码
自定义列的数据类型

接下来让我们改一下列的数据类型。默认情况下,string类型的属性会映射到数据库里varchar(255)的数据类型,number则会映射到类似于float/double这样的数据类型(取决到是什么数据库)。

但是我们不想所有的列被限制在varchar或float之类,下面来改进:

  1. import {Table, Column, PrimaryGeneratedColumn} from "typeorm";
  2. @Table()
  3. export class Photo {
  4. @PrimaryGeneratedColumn()
  5. id: number;
  6. @Column({
  7. length: 500
  8. })
  9. name: string;
  10. @Column("text")
  11. description: string;
  12. @Column()
  13. fileName: string;
  14. @Column("int")
  15. views: number;
  16. @Column()
  17. isPublished: boolean;
  18. }
复制代码
创建数据库连接

现在实体已经有了,接下来创建 app.ts 并配置数据库连接:

  1. import "reflect-metadata";
  2. import {createConnection} from "typeorm";
  3. import {Photo} from "./entity/Photo";
  4. createConnection({
  5. driver: {
  6. type: "mysql",
  7. host: "localhost",
  8. port: 3306,
  9. username: "root",
  10. password: "admin",
  11. database: "test"
  12. },
  13. entities: [
  14. Photo
  15. ],
  16. autoSchemaSync: true,
  17. }).then(connection => {
  18. // 这里可以写实体操作相关的代码
  19. }).catch(error => console.log(error));
复制代码

在例子里使用的是mysql,你也可以选择其他数据库,只需要简单修改driver选项里的数据库的类型就可以了,比如:

mysql, mariadb, postgres, sqlite, mssql or oracle.

同样可以修改host, port, username, password 以及database等设置.

把Photo实体加到数据连接的实体列表中,所有需要在这个连接下使用的实体都必须加到这个列表中。

autoSchemaSync 选项可以在应用启动时确保你的实体和数据库保持同步。

引用目录下的所有实体

接下来我们可能会创建更多的实体并把它们一一加到配置当中。

不过这样会比较麻烦,好在可以直接写上实体的目录,这样这个目录下的所有实体都可以在当前连接中被使用:

  1. import {createConnection} from "typeorm";
  2. createConnection({
  3. driver: {
  4. type: "mysql",
  5. host: "localhost",
  6. port: 3306,
  7. username: "root",
  8. password: "admin",
  9. database: "test"
  10. },
  11. entities: [
  12. __dirname + "/entity/*.js"
  13. ],
  14. autoSchemaSync: true,
  15. }).then(connection => {
  16. // here you can start to work with your entities
  17. }).catch(error => console.log(error));
复制代码
启动应用

现在可以启动 app.ts ,启动后可以发现数据库自动被初始化,并且Photo这个表也会创建出来。

  1. +-------------+--------------+----------------------------+
  2. | photo |
  3. +-------------+--------------+----------------------------+
  4. | id | int(11) | PRIMARY KEY AUTO_INCREMENT |
  5. | name | varchar(500) | |
  6. | description | text | |
  7. | filename | varchar(255) | |
  8. | views | int(11) | |
  9. | isPublished | boolean | |
  10. +-------------+--------------+----------------------------+
复制代码
添加和插入photo

现在创建一个新的photo然后存到数据库:

  1. import {createConnection} from "typeorm";
  2. createConnection(/*...*/).then(connection => {
  3. let photo = new Photo();
  4. photo.name = "Me and Bears";
  5. photo.description = "I am near polar bears";
  6. photo.filename = "photo-with-bears.jpg";
  7. photo.views = 1;
  8. photo.isPublished = true;
  9. connection.entityManager
  10. .persist(photo)
  11. .then(photo => {
  12. console.log("Photo has been saved");
  13. });
  14. }).catch(error => console.log(error));
复制代码
使用async/await语法

现在利用TypeScript的async/await语法来实现同样的功能:

  1. import {createConnection} from "typeorm";
  2. import {Photo} from "./entity/Photo";
  3. createConnection(/*...*/).then(async connection => {
  4. let photo = new Photo();
  5. photo.name = "Me and Bears";
  6. photo.description = "I am near polar bears";
  7. photo.filename = "photo-with-bears.jpg";
  8. photo.views = 1;
  9. photo.isPublished = true;
  10. await connection.entityManager.persist(photo);
  11. console.log("Photo has been saved");
  12. }).catch(error => console.log(error));
复制代码
使用EntityManager

刚刚我们创建了一个新的photo并且存进数据库。使用EntityManager可以操作实体,现在用 EntityManager 来把photo从数据库中取出来。

  1. import {createConnection} from "typeorm";
  2. import {Photo} from "./entity/Photo";
  3. createConnection(/*...*/).then(async connection => {
  4. /*...*/
  5. let savedPhotos = await connection.entityManager.find(Photo);
  6. console.log("All photos from the db: ", savedPhotos);
  7. }).catch(error => console.log(error));
复制代码

savedPhotos 会从数据库中取到的是一个Photo对象的数组

使用Repositories

现在重构下代码,使用 Repository 来代替EntityManage。每个实体都有自己的repository,可以对这个实体进行任何操作。

如果要对实体做很多操作,Repositories会比EntityManager更加方便。

  1. import {createConnection} from "typeorm";
  2. import {Photo} from "./entity/Photo";
  3. createConnection(/*...*/).then(async connection => {
  4. let photo = new Photo();
  5. photo.name = "Me and Bears";
  6. photo.description = "I am near polar bears";
  7. photo.filename = "photo-with-bears.jpg";
  8. photo.views = 1;
  9. photo.isPublished = true;
  10. let photoRepository = connection.getRepository(Photo);
  11. await photoRepository.persist(photo);
  12. console.log("Photo has been saved");
  13. let savedPhotos = await photoRepository.find();
  14. console.log("All photos from the db: ", savedPhotos);
  15. }).catch(error => console.log(error));
复制代码
从数据库中取photos

现在来尝试用Repository做一些取数据方面的操作:

  1. import {createConnection} from "typeorm";
  2. import {Photo} from "./entity/Photo";
  3. createConnection(/*...*/).then(async connection => {
  4. /*...*/
  5. let allPhotos = await photoRepository.find();
  6. console.log("All photos from the db: ", allPhotos);
  7. let firstPhoto = await photoRepository.findOneById(1);
  8. console.log("First photo from the db: ", firstPhoto);
  9. let meAndBearsPhoto = await photoRepository.findOne({ name: "Me and Bears" });
  10. console.log("Me and Bears photo from the db: ", meAndBearsPhoto);
  11. let allViewedPhotos = await photoRepository.find({ views: 1 });
  12. console.log("All viewed photos: ", allViewedPhotos);
  13. let allPublishedPhotos = await photoRepository.find({ isPublished: true });
  14. console.log("All published photos: ", allPublishedPhotos);
  15. let [allPhotos, photosCount] = await photoRepository.findAndCount();
  16. console.log("All photos: ", allPublishedPhotos);
  17. console.log("Photos count: ", allPublishedPhotos);
  18. }).catch(error => console.log(error));
复制代码
更新photo

现在来从数据库中取出一个photo,修改并更新到数据库。

  1. import {createConnection} from "typeorm";
  2. import {Photo} from "./entity/Photo";
  3. createConnection(/*...*/).then(async connection => {
  4. /*...*/
  5. let photoToUpdate = await photoRepository.findOneById(1);
  6. photoToUpdate.name = "Me, my friends and polar bears";
  7. await photoRepository.persist(photoToUpdate);
  8. }).catch(error => console.log(error));
复制代码

这个 id = 1 的photo在数据库中就成功更新了.

删除photo

再来,从数据库中删除我们的photo:

  1. import {createConnection} from "typeorm";
  2. import {Photo} from "./entity/Photo";
  3. createConnection(/*...*/).then(async connection => {
  4. /*...*/
  5. let photoToRemove = await photoRepository.findOneById(1);
  6. await photoRepository.remove(photoToRemove);
  7. }).catch(error => console.log(error));
复制代码

这个 id = 1 的photo就在数据库中被移除了。

一对一关系

来创建与另一个类的一对一关系。

新建PhotoMetadata.ts用来存photo的元信息。

  1. import {Table, Column, PrimaryGeneratedColumn, OneToOne, JoinColumn} from "typeorm";
  2. import {Photo} from "./Photo";
  3. @Table()
  4. export class PhotoMetadata {
  5. @PrimaryGeneratedColumn()
  6. id: number;
  7. @Column("int")
  8. height: number;
  9. @Column("int")
  10. width: number;
  11. @Column()
  12. orientation: string;
  13. @Column()
  14. compressed: boolean;
  15. @Column()
  16. comment: string;
  17. @OneToOne(type => Photo)
  18. @JoinColumn()
  19. photo: Photo;
  20. }
复制代码

这里我们用到了一个新的装饰器 @OneToOne ,它可以用来在两个实体之间创建一对一关系。

type => Photo 指示了我们想要连接的实体类名,这里因为TypeScript语言的支持原因不能直接用类名。

当然也可以使用 () => Photo ,但是 type => Photo 显得更有可读性。

Type变量本身并不包含任何东西。

我们同样使用了 @JoinColumn 装饰器,这个装饰器可以指定一对一关系的拥有者。

关系可以是单向的或双向的,但是只有一方是拥有者,加个这个装饰器就表示关系是给这个表服务的。

现在运行app,会新创建一个table,这个table有一个连接photo的外键:

  1. +-------------+--------------+----------------------------+
  2. | photo `译者注:应该是PhotoMetadata` |
  3. +-------------+--------------+----------------------------+
  4. | id | int(11) | PRIMARY KEY AUTO_INCREMENT |
  5. | height | int(11) | |
  6. | width | int(11) | |
  7. | comment | varchar(255) | |
  8. | compressed | boolean | |
  9. | orientation | varchar(255) | |
  10. | photo | int(11) | FOREIGN KEY |
  11. +-------------+--------------+----------------------------+
复制代码
存一个有一对一关系的对象

现在来创建一个photo,一个photo的元信息,并把它们已经连接起来。

  1. import {createConnection} from "typeorm";
  2. import {Photo} from "./entity/Photo";
  3. import {PhotoMetadata} from "./entity/PhotoMetadata";
  4. createConnection(/*...*/).then(async connection => {
  5. // 创建一个photo
  6. let photo = new Photo();
  7. photo.name = "Me and Bears";
  8. photo.description = "I am near polar bears";
  9. photo.filename = "photo-with-bears.jpg"
  10. photo.isPublished = true;
  11. // 创建一个photo的元信息
  12. let metadata = new PhotoMetadata();
  13. metadata.height = 640;
  14. metadata.width = 480;
  15. metadata.compressed = true;
  16. metadata.comment = "cybershoot";
  17. metadata.orientation = "portait";
  18. metadata.photo = photo; // 这里把两者连起来
  19. // 获取实体repositories
  20. let photoRepository = connection.getRepository(Photo);
  21. let metadataRepository = connection.getRepository(PhotoMetadata);
  22. // 先来把photo存到数据库
  23. await photoRepository.persist(photo);
  24. // photo存完了,再存下photo的元信息
  25. await metadataRepository.persist(metadata);
  26. // 搞定
  27. console.log("metadata is saved, and relation between metadata and photo is created in the database too");
  28. }).catch(error => console.log(error));
复制代码
双向关系

关系可以是单向的或是双向的.

现在PhotoMetadata和Photo的关系是单向的,关系拥有者是PhotoMetadata,Photo并不知道PhotoMetadata,这样如果要想从Photo里得到PhotoMetadata的数据会比较麻烦。

现在来改变一下,把单向改成双向:

  1. import {Table, Column, PrimaryGeneratedColumn, OneToOne, JoinColumn} from "typeorm";
  2. import {Photo} from "./Photo";
  3. @Table()
  4. export class PhotoMetadata {
  5. /* ... 其他列 */
  6. @OneToOne(type => Photo, photo => photo.metadata)
  7. @JoinColumn()
  8. photo: Photo;
  9. }
复制代码
  1. import {Table, Column, PrimaryGeneratedColumn, OneToOne} from "typeorm";
  2. import {PhotoMetadata} from "./PhotoMetadata";
  3. @Table()
  4. export class Photo {
  5. /* ... 其他列 */
  6. @OneToOne(type => PhotoMetadata, photoMetadata => photoMetadata.photo)
  7. metadata: PhotoMetadata;
  8. }
复制代码

photo => photo.metadata 是用来指定反向关系的字段名字,photo.metadata就指出了Photo里的metadata字段名字。

当然也可以使用 @OneToOne('metadata') 来达到同样的目的,不过这种对于以后的代码重构不友好。

按上面说的, @JoinColumn 只能在关系的一边使用来使这边做为关系的拥有者,关系拥有者在数据库里的表现就是拥有一个外键列。

取出关系对象的数据

现在来用一个查询来取出photo以及它的元信息。

有两种方式,一是用 FindOptions ,另一个是使用 QueryBuilder 。

先试下 FindOptions ,通过指定 FindOptions 接口作为参数来使用 Repository.find 方法可以完成非常复杂的查询。

  1. import {createConnection} from "typeorm";
  2. import {Photo} from "./entity/Photo";
  3. import {PhotoMetadata} from "./entity/PhotoMetadata";
  4. createConnection(/*...*/).then(async connection => {
  5. /*...*/
  6. let photoRepository = connection.getRepository(Photo);
  7. let photos = await photoRepository.find({
  8. alias: "photo",
  9. innerJoinAndSelect: {
  10. "metadata": "photo.metadata"
  11. }
  12. });
  13. }).catch(error => console.log(error));
复制代码

返回的photos是从数据库里取回的photo的数组,每个photo都包含它的元信息。

alias 是FindOptions的一个必需选项,这是你自己在select里定义的别名,然后需要用在接下来的 where, order by, group by, join 以及其他表达式.

这里还用到了 innerJoinAndSelect ,表示内联查询photo.metadata的数据。

"photo.metadata" 里"photo"是一个别名,"metadata"则是你想查询的那个对象的属性名。

"metadata" : 是内联返回数据的新的别名.

下面来尝试第二种方式: QueryBuilder 来达到同样的目的. 使用 QueryBuilder 可以优雅完成复杂的查询:

  1. import {createConnection} from "typeorm";
  2. import {Photo} from "./entity/Photo";
  3. import {PhotoMetadata} from "./entity/PhotoMetadata";
  4. createConnection(/*...*/).then(async connection => {
  5. /*...*/
  6. let photoRepository = connection.getRepository(Photo);
  7. let photos = await photoRepository.createQueryBuilder("photo")
  8. .innerJoinAndSelect("photo.metadata", "metadata")
  9. .getMany();
  10. }).catch(error => console.log(error));
复制代码
使用 cascade 选项来自动保存关系着的对象

上面要保存关系对象需要一个一个来保存,略显麻烦。

如果我们需要当关系对象中的一个被保存后,另一个也同样被保存,则可以使用 cascade 选项来做到。

稍微改下 @OneToOne 装饰:

  1. export class Photo {
  2. /// ... 其他列
  3. @OneToOne(type => PhotoMetadata, metadata => metadata.photo, {
  4. cascadeInsert: true,
  5. cascadeUpdate: true,
  6. cascadeRemove: true
  7. })
  8. metadata: PhotoMetadata;
  9. }
复制代码
cascadeInsert - 如果表中没有关系中的metadata,则自动insert,即我们不需要再手动insert一个新的photoMetadata对象。 cascadeUpdate - 如果metadata有变化,则自动update。 cascadeRemove - 如果把photo里的metadata移除了,也就是为空,则会自动remove表中的这条metadata数据。

使用cascadeInsert就可以不需要像上面那边先存photo再存metadata了。

现在我们来单单存photo对象,由于cascade的作用,metadata也会自动存上。

  1. createConnection(options).then(async connection => {
  2. // 创建photo对象
  3. let photo = new Photo();
  4. photo.name = "Me and Bears";
  5. photo.description = "I am near polar bears";
  6. photo.filename = "photo-with-bears.jpg"
  7. photo.isPublished = true;
  8. // 创建photo metadata 对象
  9. let metadata = new PhotoMetadata();
  10. metadata.height = 640;
  11. metadata.width = 480;
  12. metadata.compressed = true;
  13. metadata.comment = "cybershoot";
  14. metadata.orientation = "portait";
  15. photo.metadata = metadata; // 连接起来
  16. // 得到repository
  17. let photoRepository = connection.getRepository(Photo);
  18. // 存photo
  19. await photoRepository.persist(photo);
  20. // photo metadata也自动存上了
  21. console.log("Photo is saved, photo metadata is saved too.")
  22. }).catch(error => console.log(error));
复制代码
多对一/一对多关系

接下来显示多对一/一对多关系。

假设一个photo会有一个author,并且每个author可以有很多photo。

先创建Author实体:

  1. import {Table, Column, PrimaryGeneratedColumn, OneToMany, JoinColumn} from "typeorm";
  2. import {Photo} from "./Photo";
  3. @Table()
  4. export class Author {
  5. @PrimaryGeneratedColumn()
  6. id: number;
  7. @Column()
  8. name: string;
  9. @OneToMany(type => Photo, photo => photo.author) // 备注:下面会为Photo创建author属性
  10. photos: Photo[];
  11. }
复制代码

Author包含一个反向的关系, OneToMany 总是反向的,并且总是与 ManyToOne 成对出现。

现在来为Photo加上关系拥有者。

  1. import {Table, Column, PrimaryGeneratedColumn, ManyToOne} from "typeorm";
  2. import {PhotoMetadata} from "./PhotoMetadata";
  3. import {Author} from "./Author";
  4. @Table()
  5. export class Photo {
  6. /* ... 其他列 */
  7. @ManyToOne(type => Author, author => author.photos)
  8. author: Author;
  9. }
复制代码

在 ManyToOne/OneToMany 关系中,拥有者一边总是 ManyToOne 。 译者注:拥有外键者即关系拥有者
也就是 ManyToOne 的那个字段存的是另一个对象的id。 译者注:也就是上面的author虽然属性是Author,但在数据库中类型是Author id的类型,存的也是id

执行上面的代码将会自动创建author表,如下:

  1. +-------------+--------------+----------------------------+
  2. | author |
  3. +-------------+--------------+----------------------------+
  4. | id | int(11) | PRIMARY KEY AUTO_INCREMENT |
  5. | name | varchar(255) | |
  6. +-------------+--------------+----------------------------+
复制代码

因为photo表已经存在,所以不是增加而是修改photo表 - 添加一个新外键列author:

  1. +-------------+--------------+----------------------------+
  2. | photo |
  3. +-------------+--------------+----------------------------+
  4. | id | int(11) | PRIMARY KEY AUTO_INCREMENT |
  5. | name | varchar(255) | |
  6. | description | varchar(255) | |
  7. | filename | varchar(255) | |
  8. | isPublished | boolean | |
  9. | author | int(11) | FOREIGN KEY |
  10. +-------------+--------------+----------------------------+
复制代码
多对多关系

假设photo可以存在多个相册中,并且相册里可以包含多个photo。

先创建一个 Album 类

  1. import {Table, PrimaryGeneratedColumn, Column, ManyToMany, JoinTable} from "typeorm";
  2. @Table()
  3. export class Album {
  4. @PrimaryGeneratedColumn()
  5. id: number;
  6. @Column()
  7. name: string;
  8. @ManyToMany(type => Photo, photo => photo.albums, { // 备注: 会在下面的Photo类里添加"albums"属性
  9. cascadeInsert: true, // 在添加Album时,会自动添加相册里的Photo
  10. cascadeUpdate: true, // 在更新Album时,会自动更新相册里的Photo
  11. cascadeRemove: true // 在移除Album时,会自动移除相册里的Photo
  12. })
  13. @JoinTable()
  14. photos: Photo[] = []; // 初始化个Photo数组
  15. }
复制代码

@JoinTable 多对多关系拥有者必须指定的。

接着给 Photo 实体加个反向关系:

  1. export class Photo {
  2. /// ... 其他列
  3. @ManyToMany(type => Album, album => album.photos, {
  4. cascadeInsert: true, // 在添加Album时,会自动添加相册里的Photo
  5. cascadeUpdate: true, // 在更新Album时,会自动更新相册里的Photo
  6. cascadeRemove: true // 在移除Album时,会自动移除相册里的Photo
  7. })
  8. albums: Album[] = []; // 初始化个Album数组
  9. }
复制代码

执行上面的代码后会自动创建一个叫 album_photos_photo_albums联接表 :

  1. +-------------+--------------+----------------------------+
  2. | album_photos_photo_albums |
  3. +-------------+--------------+----------------------------+
  4. | album_id_1 | int(11) | PRIMARY KEY FOREIGN KEY |
  5. | photo_id_2 | int(11) | PRIMARY KEY FOREIGN KEY |
  6. +-------------+--------------+----------------------------+
复制代码

记得把 Album 实体加到ConnectionOptions中:

  1. const options: CreateConnectionOptions = {
  2. // ... 其他配置
  3. entities: [Photo, PhotoMetadata, Author, Album]
  4. };
复制代码

现在来往数据库里插入albums和photos

  1. let connection = await createConnection(options);
  2. // 创建两个albums
  3. let album1 = new Album();
  4. album1.name = "Bears";
  5. let album2 = new Album();
  6. album2.name = "Me";
  7. // 创建两个photos
  8. let photo1 = new Photo();
  9. photo1.name = "Me and Bears";
  10. photo1.description = "I am near polar bears";
  11. photo1.filename = "photo-with-bears.jpg";
  12. photo1.albums.push(album1);
  13. let photo2 = new Photo();
  14. photo2.name = "Me and Bears";
  15. photo2.description = "I am near polar bears";
  16. photo2.filename = "photo-with-bears.jpg";
  17. photo2.albums.push(album2);
  18. // 获取Photo的repository
  19. let photoRepository = connection.getRepository(Photo);
  20. // 依次存储photos,由于cascade,albums也同样会自动存起来
  21. await photoRepository.persist(photo1);
  22. await photoRepository.persist(photo2);
  23. console.log("Both photos have been saved");
复制代码
使用QueryBuilder

可以利用QueryBuilder来构建一个非常复杂的查询,例如:

  1. let photoRepository = connection.getRepository(Photo);
  2. let photos = await photoRepository
  3. .createQueryBuilder("photo") // 别名,必填项,用来指定本次查询
  4. .innerJoinAndSelect("photo.metadata", "metadata")
  5. .leftJoinAndSelect("photo.albums", "albums")
  6. .where("photo.isPublished=true")
  7. .andWhere("(photo.name=:photoName OR photo.name=:bearName)")
  8. .orderBy("photo.id", "DESC")
  9. .setFirstResult(5)
  10. .setMaxResults(10)
  11. .setParameters({ photoName: "My", bearName: "Mishka" })
  12. .getMany();
复制代码

这个查询会查找已经published的,并且name是"My"或"Mishka",

得到的结果会从第5个开始(分页偏移决定的),

并且只会得到10个结果(分页每页个数决定的),

所得结果是以id的倒序排序的,

Photo的albums是左联接,photo的metadata是内联接。

来自:http://www.cnblogs.com/brookshi/p/6446155.html



回复

使用道具 举报