typeorm数据库ORM框架中文文档 js，node，typescript

TypeORM是一个ORM框架，它能够运行在NodeJS、浏览器、Cordova、PhoneGap、Ionic、React Native、Expo和Electron平台上，能够与TypeScript和JavaScript (ES5, ES6, ES7)一块儿使用。 它的目标是始终支持最新的JavaScript特性并提供额外的特性以帮助你开发任何使用数据库的应用程序 —— 不论是只有几张表的小型应用仍是拥有多数据库的大型企业应用。

不一样于现有的全部其余JavaScript ORM框架，TypeORM支持Active Record和Data Mapper模式，这意味着你用最有效的方法编写高质量的、松耦合的、可扩展的、可维护的应用程序。

TypeORM参考了不少其余优秀ORM的实现, 好比 Hibernate, Doctrine 和 Entity Framework.

TypeORM 的一些特性：

• 支持Active Record和Data Mapper（你能够自由选择）
• 实体和列
• 数据库特性列类型
• 实体管理
• 存储库和自定义存储库
• 清洁对象关系模型
• 关联（关系）
• 贪婪和延迟关系
• 单向的，双向的和自引用的关系
• 支持多重继承模式
• 级联
• 索引
• 事务
• 迁移和自动迁移
• 链接池
• 复制
• 使用多个数据库链接
• 使用多个数据库类型
• 跨数据库和跨模式查询
• 优雅的语法，灵活而强大的QueryBuilder
• 左联接和内联接
• 准确的分页链接查询
• 查询缓存
• 原始结果流
• 日志
• 监听者和订阅者（钩子）
• 支持闭包表模式
• 在模型或者分离的配置文件中声明模式
• json / xml / yml / env格式的链接配置
• 支持 MySQL / MariaDB / Postgres / SQLite / Microsoft SQL Server / Oracle / sql.js
• 支持 MongoDB NoSQL 数据库
• 在NodeJS / 浏览器 / Ionic / Cordova / React Native / Expo / Electron平台上工做
• 支持 TypeScript 和 JavaScript
• 产生出高性能、灵活、清晰和可维护的代码
• 遵循全部可能的最佳实践
• 命令行工具

还有更多...

使用TypeORM你的模型是这样的：

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

@Entity()
export class User {

    @PrimaryGeneratedColumn()
    id: number;

    @Column()
    firstName: string;

    @Column()
    lastName: string;

    @Column()
    age: number;

}
复制代码

你的域逻辑是这样的：

const user = new User();
user.firstName = "Timber";
user.lastName = "Saw";
user.age = 25;
await repository.save(user);

const allUsers = await repository.find();
const firstUser = await repository.findOne(1);
const timber = await repository.findOne({ firstName: "Timber", lastName: "Saw" });

await repository.remove(timber);
复制代码

或者，你若是喜欢使用“ActiveRecord”实现，你也可使用它：

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

@Entity()
export class User extends BaseEntity {

    @PrimaryGeneratedColumn()
    id: number;

    @Column()
    firstName: string;

    @Column()
    lastName: string;

    @Column()
    age: number;

}
复制代码

你的域逻辑是这样的：

const user = new User();
user.firstName = "Timber";
user.lastName = "Saw";
user.age = 25;
await user.save();

const allUsers = await User.find();
const firstUser = await User.findOne(1);
const timber = await User.findOne({ firstName: "Timber", lastName: "Saw" });

await timber.remove();
复制代码

请注意

这个文档可能不是最新的。 能够去官网查看最新的英文文档。 很是欢迎你的贡献。

安装

1. 安装TypeORM:

   npm install typeorm --save

2. 须要安装依赖模块 reflect-metadata :

   npm install reflect-metadata --save

   在应用里全局引用一下:

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

3. 你可能须要安装node类型：

   npm install @types/node --save

4. 安装数据库驱动:

   • MySQL 或 MariaDB

     npm install mysql --save

   • PostgreSQL

     npm install pg --save

   • SQLite

     npm install sqlite3 --save

   • Microsoft SQL Server

     npm install mssql --save

   • sql.js

     npm install sql.js --save

   • Oracle (experimental)

     npm install oracledb --save

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

   使用oracle驱动须要参考安装说明：地址.

TypeScript配置

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

"emitDecoratorMetadata": true,
"experimentalDecorators": true,
复制代码

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

快速开始

开始使用TypeORM的最快方法是使用它的CLI命令生成一个初始项目。 快速开始只有在NodeJS应用程序中使用TypeORM才可使用。 若是你正在使用其余平台，请看分步指南。

首先全局安装TypeORM：

npm install typeorm -g
复制代码

而后转到新项目的目录并运行该命令：

typeorm init --name MyProject --database mysql
复制代码

name即项目的名称，database是你将使用的数据库。数据库能够是下列值之一：mysql、mariadb、postgres、sqlite、mssql、oracle、mongodb、cordova、react-native、expo。

该命令将在MyProject目录中生成一个新项目，其中包含如下文件：

MyProject
├── src              // 放你的 TypeScript 代码
│   ├── entity       // 放实体（数据库模型）的目录
│   │   └── User.ts  // 实体的案例
│   ├── migration    // 迁移文件目录
│   └── index.ts     // 应用程序入口
├── .gitignore       // 标准git忽略文件
├── ormconfig.json   // ORM和数据链接配置
├── package.json     // node模块依赖
├── README.md        // 简单的说明文件
└── tsconfig.json    // TypeScript编译配置
复制代码

你也能够在现有的node项目目录执行typeorm init，可是必定要当心 - 它可能会覆盖你已经有的一些文件。

下一步是安装项目依赖

cd MyProject
npm install
复制代码

在安装过程当中，修改 ormconfig.json 文件将本身的数据库链接配置选项放在其中：

{
   "type": "mysql",
   "host": "localhost",
   "port": 3306,
   "username": "test",
   "password": "test",
   "database": "test",
   "synchronize": true,
   "logging": false,
   "entities": [
      "src/entity/**/*.ts"
   ],
   "migrations": [
      "src/migration/**/*.ts"
   ],
   "subscribers": [
      "src/subscriber/**/*.ts"
   ]
}
复制代码

一般来讲，大多数时候你只须要配置host，username，password，database 或者 port 选项。

配置和模块安装都完成以后，就能够运行应用程序了：

npm start
复制代码

就是这样，你的应用程序应该成功地运行并将一个新用户插入到数据库中。 你能够继续这个项目，集成你须要的其余模块，并建立更多的实体。

运行typeorm init --name MyProject --database mysql --express命令能够安装express，生成一个更高级的项目。

分步指南

你对ORM的指望是什么？ 首先，你预期它将为你建立数据库表，并查找/插入/更新/删除你的数据，而没必要编写大量难以维护的SQL查询。 本指南将向你展现如何从头开始设置TypeORM，并让它按照你所指望的ORM进行。

建立模型

与数据库一块儿工做从建立表开始。 如何告诉TypeORM建立一个数据库表？ 答案是 - 经过模型。 你的应用程序中的模型就是你的数据库中的表。

例如你有一个 Photo 模型：

export class Photo {
    id: number;
    name: string;
    description: string;
    filename: string;
    views: number;
}
复制代码

你想在你的数据库中存储照片。 要在数据库中存储东西，首先须要一个数据库表，并从模型建立数据库表。 不是全部的模型，而仅仅是那些你定义为实体。

建立实体

实体是你用 @Entity 装饰的模型。 将为这些模型建立一个数据库表。 使用TypeORM你将在任何地方使用实体。 你可使用他们加载/插入/更新/删除并执行其余操做。

让咱们把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列自动生成(这就是所谓的自动递增/按顺序/连续的/生成惟一标识列)。 要作到这一点，你须要将 @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)类型（取决于数据库类型）。 数字被映射到一个integer类型（取决于数据库类型）。 咱们不但愿全部的列都是有限的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，你也能够选择其余数据库，只须要简单修改driver选项里的数据库的类型就能够了，好比：mysql、mariadb、postgres、sqlite、mssql、oracle、cordova、react-native、expo或mongodb 一样能够修改host, port, username, password 以及database等设置。

把Photo实体加到数据链接的实体列表中，全部须要在这个链接下使用的实体都必须加到这个列表中。

synchronize选项能够在应用启动时确保你的实体和数据库保持同步。

引用目录下的全部实体

接下来咱们可能会建立更多的实体并把它们一一加到配置当中。 不过这样会比较麻烦，好在能够直接写上实体的目录，这样这个目录下的全部实体均可以在当前链接中被使用：

import {createConnection} from "typeorm";

createConnection({
    driver: {
        type: "mysql",
        host: "localhost",
        port: 3306,
        username: "root",
        password: "admin",
        database: "test"
    },
    entities: [
        __dirname + "/entity/*.js"
    ],
    synchronize: true,
}).then(connection => {
    // here you can start to work with your entities
}).catch(error => console.log(error));
复制代码

启动应用

如今能够启动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";

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;

    connection.manager
            .save(photo)
            .then(photo => {
                console.log("Photo has been saved");
            });

}).catch(error => console.log(error));
复制代码

使用async/await语法

如今利用TypeScript的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));
复制代码

使用EntityManager

刚刚咱们建立了一个新的photo而且存进数据库。使用EntityManager能够操做实体，如今用EntityManager来把photo从数据库中取出来。

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对象的数组

使用Repositories

如今重构下代码，使用Repository来代替EntityManage。每一个实体都有本身的repository，能够对这个实体进行任何操做。 若是要对实体作不少操做，Repositories会比EntityManager更加方便。

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));
复制代码

从数据库中取photos

如今来尝试用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(1);
    console.log("First photo from the db: ", firstPhoto);

    let meAndBearsPhoto = await photoRepository.findOne({ 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

如今来从数据库中取出一个photo，修改并更新到数据库。

import {createConnection} from "typeorm";
import {Photo} from "./entity/Photo";

createConnection(/*...*/).then(async connection => {

    /*...*/
    let photoToUpdate = await photoRepository.findOne(1);
    photoToUpdate.name = "Me, my friends and polar bears";
    await photoRepository.save(photoToUpdate);

}).catch(error => console.log(error));
复制代码

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

删除photo

再来，从数据库中删除咱们的photo:

import {createConnection} from "typeorm";
import {Photo} from "./entity/Photo";

createConnection(/*...*/).then(async connection => {

    /*...*/
    let photoToRemove = await photoRepository.findOne(1);
    await photoRepository.remove(photoToRemove);

}).catch(error => console.log(error));
复制代码

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

一对一关系

来建立与另外一个类的一对一关系。 新建PhotoMetadata.ts用来存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指示了咱们想要链接的实体类名，这里由于TypeScript语言的支持缘由不能直接用类名。 固然也可使用() => Photo，可是type => Photo显得更有可读性。 Type变量自己并不包含任何东西。

咱们一样使用了@JoinColumn装饰器，这个装饰器能够指定一对一关系的拥有者。 关系能够是单向的或双向的，可是只有一方是拥有者，加个这个装饰器就表示关系是给这个表服务的。

如今运行app，会新建立一个table，这个table有一个链接photo的外键：

+-------------+--------------+----------------------------+
|                      photo `译者注：应该是PhotoMetadata` |
+-------------+--------------+----------------------------+
| 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，一个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的元信息
    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存完了，再存下photo的元信息
    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的数据会比较麻烦。 如今来改变一下，把单向改为双向：

import {Entity, Column, PrimaryGeneratedColumn, OneToOne, JoinColumn} from "typeorm";
import {Photo} from "./Photo";

@Entity()
export class PhotoMetadata {

    /* ... 其余列 */

    @OneToOne(type => Photo, photo => photo.metadata)
    @JoinColumn()
    photo: Photo;
}
复制代码

import {Entity, Column, PrimaryGeneratedColumn, OneToOne} from "typeorm";
import {PhotoMetadata} from "./PhotoMetadata";

@Entity()
export class Photo {

    /* ... 其余列 */

    @OneToOne(type => PhotoMetadata, photoMetadata => photoMetadata.photo)
    metadata: PhotoMetadata;
}
复制代码

photo => photo.metadata 是用来指定反向关系的字段名字，photo.metadata就指出了Photo里的metadata字段名字。 固然也可使用@OneToOne('metadata')来达到一样的目的，不过这种对于之后的代码重构不友好。

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

取出关系对象的数据

如今来用一个查询来取出photo以及它的元信息。 有两种方式，一是用FindOptions，另外一个是使用QueryBuilder。 先试下FindOptions，经过指定FindOptions接口做为参数来使用Repository.find方法能够完成很是复杂的查询。

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是从数据库里取回的photo的数组，每一个photo都包含它的元信息。

alias 是FindOptions的一个必需选项，这是你本身在select里定义的别名，而后须要用在接下来的 where, order by, group by, join 以及其余表达式.

这里还用到了innerJoinAndSelect，表示内联查询photo.metadata的数据。 "photo.metadata"里"photo"是一个别名，"metadata"则是你想查询的那个对象的属性名。 "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));
复制代码

使用 cascade 选项来自动保存关系着的对象

上面要保存关系对象须要一个一个来保存，略显麻烦。 若是咱们须要当关系对象中的一个被保存后，另外一个也一样被保存，则可使用cascade选项来作到。 稍微改下@OneToOne装饰:

export class Photo {
    /// ... 其余列

    @OneToOne(type => PhotoMetadata, metadata => metadata.photo, {
        cascade: true,
    })
    metadata: PhotoMetadata;
}
复制代码

使用cascade就能够不须要像上面那边先存photo再存metadata了。 如今咱们来单单存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; // 链接起来

    // 获得repository
    let photoRepository = connection.getRepository(Photo);

    // 存photo
    await photoRepository.save(photo);
    // photo metadata也自动存上了
    console.log("Photo is saved, photo metadata is saved too.")

}).catch(error => console.log(error));
复制代码

多对一/一对多关系

接下来显示多对一/一对多关系。 假设一个photo会有一个author，而且每一个author能够有不少photo。 先建立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) // 备注：下面会为Photo建立author属性
    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 {

    /* ... 其余列 */

    @ManyToOne(type => Author, author => author.photos)
    author: Author;
}
复制代码

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

执行上面的代码将会自动建立author表，以下:

+-------------+--------------+----------------------------+
|                          author                         |
+-------------+--------------+----------------------------+
| id          | int(11)      | PRIMARY KEY AUTO_INCREMENT |
| name        | varchar(255) |                            |
+-------------+--------------+----------------------------+
复制代码

由于photo表已经存在，因此不是增长而是修改photo表 - 添加一个新外键列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能够存在多个相册中，而且相册里能够包含多个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 {
    /// ... 其余列

    @ManyToMany(type => Album, album => album.photos)
    albums: Album[];
}
复制代码

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

+-------------+--------------+----------------------------+
|                album_photos_photo_albums                |
+-------------+--------------+----------------------------+
| album_id    | int(11)      | PRIMARY KEY FOREIGN KEY    |
| photo_id    | int(11)      | PRIMARY KEY FOREIGN KEY    |
+-------------+--------------+----------------------------+
复制代码

记得把Album实体加到ConnectionOptions中:

const options: ConnectionOptions = {
    // ... 其余配置
    entities: [Photo, PhotoMetadata, Author, Album]
};
复制代码

如今来往数据库里插入albums和photos

let connection = await createConnection(options);

// 建立几张相册
let album1 = new Album();
album1.name = "Bears";
await connection.manager.save(album1);

let album2 = new Album();
album2.name = "Me";
await connection.manager.save(album2);

// 建立几个相片
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);

// 如今咱们的相片已经保存，而且添加到相册里面了
// 让咱们开始加载它们：
const loadedPhoto = await connection
    .getRepository(Photo)
    .findOne(1, { 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来构建一个很是复杂的查询，例如：

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"， 获得的结果会从第5个开始（分页偏移决定的）， 而且只会获得10个结果（分页每页个数决定的）， 所得结果是以id的倒序排序的， Photo的albums是左联接，photo的metadata是内联接。

你将在应用程序中大量使用QueryBuilder。 了解更多QueryBuilder这里.

样例

看看样例里这些例子的用法

这些仓库，你能够克隆下来帮助你开始:

• Example how to use TypeORM with TypeScript
• Example how to use TypeORM with JavaScript
• Example how to use TypeORM with JavaScript and Babel
• Example how to use TypeORM with TypeScript and SystemJS in Browser
• Example how to use Express and TypeORM
• Example how to use Koa and TypeORM
• Example how to use TypeORM with MongoDB
• Example how to use TypeORM in a Cordova/PhoneGap app
• Example how to use TypeORM with an Ionic app
• Example how to use TypeORM with React Native
• Example how to use TypeORM with Electron using JavaScript
• Example how to use TypeORM with Electron using TypeScript

扩展

这几个扩展能够简化TypeORM的使用，并将其与其余模块集成：

• TypeORM + GraphQL framework
• TypeORM integration with TypeDI
• TypeORM integration with routing-controllers
• Models generation from existing database - typeorm-model-generator

转载自：点击查看文档来源

留言

欢迎查看使用TypeORM 和 nestjs 实现的Mock Server 前端Mock接口和数据方案