<p>TypeORM github: <a href="/misc/goto?guid=4959739170727615841" rel="nofollow,noindex">https://github.com/typeorm/typeorm</a></p>    <p>这篇译文是从TypeORM github上的使用说明上翻译过来的，已经提交PR并merge到库中了。</p>    <p>TypeORM是一个采用TypeScript编写的用于Node.js的优秀ORM框架，支持使用TypeScript或Javascript(ES5, ES6, ES7)开发。</p>    <p>目标是保持支持最新的Javascript特性来帮助开发各种用到数据库的应用 - 不管是轻应用还是企业级的。</p>    <p>TypeORM可以做到：</p>    <ul>     <li>根据Models自动创建数据库Table</li>     <li>可以透明的insert/update/delete数据库对象</li>     <li>映射数据库table到javascript对象，映射table column到javascript对象属性</li>     <li>提供表的一对一，多对一，一对多，多对多关系处理</li>     <li>还有更多 ...</li>    </ul>    <p>不同于其他的JavaScript ORM，TypeORM使用的是数据映射模式，可以很轻松的创建出松耦合、可伸缩、可维护的应用。</p>    <p>TypeORM可以帮助开发者专注于业务逻辑，而不用过于担心数据存储的问题。</p>    <p>TypeORM参考了很多其他优秀ORM的实现, 比如 Hibernate , Doctrine 和 Entity Framework .</p>    <h2>安装</h2>    <ol>     <li> <p>安装TypeORM:</p> <p>npm install typeorm --save</p> </li>     <li> <p>需要安装依赖模块 reflect-metadata :</p> <p>npm install reflect-metadata --save</p> <p>在应用里全局引用一下:</p>      <ul>       <li>比如在app.ts的入口处 require("reflect-metadata")</li>      </ul> </li>     <li> <p>安装数据库驱动:</p>      <ul>       <li> <p>MySQL或 <strong>MariaDB</strong></p> <p>npm install mysql --save</p> </li>       <li> <p>Postgres</p> <p>npm install pg --save</p> </li>       <li> <p>SQLite</p> <p>npm install sqlite3 --save</p> </li>       <li> <p>Microsoft SQL Server</p> <p>npm install mssql --save</p> </li>       <li> <p>Oracle(experimental)</p> <p>npm install oracledb --save</p> </li>      </ul> <p>可以根据你的数据库选择安装上面的任意一个.</p> <p>使用oracle驱动需要参考安装说明： <a href="/misc/goto?guid=4958863645726583877" rel="nofollow,noindex">地址</a> .</p> </li>    </ol>    <p>TypeScript配置</p>    <p>确保你的TypeScript编译器的版本大于 <strong>2.1</strong> ，并且在 tsconfig.json 开启下面设置:</p>    <pre>  <code class="language-javascript">"emitDecoratorMetadata": true,  "experimentalDecorators": true,</code></pre>    <p>同时需要开启编译选项里的 lib 下的 es6 或者从 @typings 安装 es6-shim</p>    <p>Node.js 版本</p>    <p>TypeORM在Node.JS 4.0或以上版本上测试通过。</p>    <p>如果在应用启动过程中出错可以尝试升级node.js到最新版本。</p>    <p>在浏览器中使用WebSQL (试用)</p>    <p>TypeORM可以在浏览器环境中工作，并且试验性的支持WebSQL</p>    <p>如果在浏览器环境中使用TypeORM需要使用 npm i typeorm-browser 来替代 typeorm .</p>    <h2>快速开始</h2>    <p>在TypeORM中，数据库table都是从实体中创建。</p>    <p>所谓 <em>实体</em> 其实就是用装饰器 @Table 装饰的一个model。</p>    <p>可以直接从数据库中得到包含数据的实体对象，并且可以通过实体进行数据库表的insert/update/remove。</p>    <p>来看看这个model entity/Photo.ts :</p>    <pre>  <code class="language-javascript">export class Photo {      id: number;      name: string;      description: string;      fileName: string;      views: number;  }</code></pre>    <h3>创建实体</h3>    <p>现在把Model变成实体:</p>    <pre>  <code class="language-javascript">import {Table} from "typeorm";    @Table()  export class Photo {      id: number;      name: string;      description: string;      fileName: string;      views: number;      isPublished: boolean;  }</code></pre>    <h3>添加table列</h3>    <p>已经有了一个table，每个table都有column.</p>    <p>现在来添加列.</p>    <p>可以使用装饰器 @Column 来把model的属性变成列：</p>    <pre>  <code class="language-javascript">import {Table, Column} from "typeorm";    @Table()  export class Photo {        @Column()      id: number;        @Column()      name: string;        @Column()      description: string;        @Column()      fileName: string;        @Column()      views: number;        @Column()      isPublished: boolean;  }</code></pre>    <h3>创建一个主键列</h3>    <p>很好， 现在ORM马上就可以在数据库中生成这个photo表，不过还漏了一个，每个table都必须要有主键列，所以要加上它。</p>    <p>可以用 @PrimaryColumn 装饰器来标记一个主键列。</p>    <pre>  <code class="language-javascript">import {Table, Column, PrimaryColumn} from "typeorm";    @Table()  export class Photo {        @PrimaryColumn()      id: number;        @Column()      name: string;        @Column()      description: string;        @Column()      fileName: string;        @Column()      views: number;        @Column()      isPublished: boolean;  }</code></pre>    <h3>创建自增长/自生成/顺序化的列</h3>    <p>如果你想创建自增长/自生成/顺序化的列，需要把column的type改成integer并且给主键列加上一个属性 { generated: true }</p>    <pre>  <code class="language-javascript">import {Table, Column, PrimaryColumn} from "typeorm";    @Table()  export class Photo {        @PrimaryColumn("int", { generated: true })      id: number;        @Column()      name: string;        @Column()      description: string;        @Column()      fileName: string;        @Column()      views: number;        @Column()      isPublished: boolean;  }</code></pre>    <h3>使用 @PrimaryGeneratedColumn 装饰器</h3>    <p>现在photo表的id可能自动生成自动增长，不过还是有点麻烦，这个一个很常见的功能，所以有一个专门的装饰器 @PrimaryGeneratedColumn 来实现相同的功能。</p>    <pre>  <code class="language-javascript">import {Table, Column, PrimaryGeneratedColumn} from "typeorm";    @Table()  export class Photo {        @PrimaryGeneratedColumn()      id: number;        @Column()      name: string;        @Column()      description: string;        @Column()      fileName: string;        @Column()      views: number;        @Column()      isPublished: boolean;  }</code></pre>    <h3>自定义列的数据类型</h3>    <p>接下来让我们改一下列的数据类型。默认情况下，string类型的属性会映射到数据库里varchar(255)的数据类型，number则会映射到类似于float/double这样的数据类型（取决到是什么数据库）。</p>    <p>但是我们不想所有的列被限制在varchar或float之类，下面来改进：</p>    <pre>  <code class="language-javascript">import {Table, Column, PrimaryGeneratedColumn} from "typeorm";    @Table()  export class Photo {        @PrimaryGeneratedColumn()      id: number;        @Column({          length: 500      })      name: string;        @Column("text")      description: string;        @Column()      fileName: string;        @Column("int")      views: number;        @Column()      isPublished: boolean;  }</code></pre>    <h3>创建数据库连接</h3>    <p>现在实体已经有了，接下来创建 app.ts 并配置数据库连接：</p>    <pre>  <code class="language-javascript">import "reflect-metadata";  import {createConnection} from "typeorm";  import {Photo} from "./entity/Photo";    createConnection({      driver: {          type: "mysql",          host: "localhost",          port: 3306,          username: "root",          password: "admin",          database: "test"      },      entities: [          Photo      ],      autoSchemaSync: true,  }).then(connection => {      // 这里可以写实体操作相关的代码   }).catch(error => console.log(error));</code></pre>    <p>在例子里使用的是mysql，你也可以选择其他数据库，只需要简单修改driver选项里的数据库的类型就可以了，比如：</p>    <p>mysql, mariadb, postgres, sqlite, mssql or oracle.</p>    <p>同样可以修改host, port, username, password 以及database等设置.</p>    <p>把Photo实体加到数据连接的实体列表中，所有需要在这个连接下使用的实体都必须加到这个列表中。</p>    <p>autoSchemaSync 选项可以在应用启动时确保你的实体和数据库保持同步。</p>    <h3>引用目录下的所有实体</h3>    <p>接下来我们可能会创建更多的实体并把它们一一加到配置当中。</p>    <p>不过这样会比较麻烦，好在可以直接写上实体的目录，这样这个目录下的所有实体都可以在当前连接中被使用：</p>    <pre>  <code class="language-javascript">import {createConnection} from "typeorm";    createConnection({      driver: {          type: "mysql",          host: "localhost",          port: 3306,          username: "root",          password: "admin",          database: "test"      },      entities: [          __dirname + "/entity/*.js"      ],      autoSchemaSync: true,  }).then(connection => {      // here you can start to work with your entities  }).catch(error => console.log(error));</code></pre>    <h3>启动应用</h3>    <p>现在可以启动 app.ts ，启动后可以发现数据库自动被初始化，并且Photo这个表也会创建出来。</p>    <pre>  <code class="language-javascript">+-------------+--------------+----------------------------+  |                         photo                           |  +-------------+--------------+----------------------------+  | id          | int(11)      | PRIMARY KEY AUTO_INCREMENT |  | name        | varchar(500) |                            |  | description | text         |                            |  | filename    | varchar(255) |                            |  | views       | int(11)      |                            |  | isPublished | boolean      |                            |  +-------------+--------------+----------------------------+</code></pre>    <h3>添加和插入photo</h3>    <p>现在创建一个新的photo然后存到数据库：</p>    <pre>  <code class="language-javascript">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.entityManager              .persist(photo)              .then(photo => {                  console.log("Photo has been saved");              });    }).catch(error => console.log(error));</code></pre>    <h3>使用async/await语法</h3>    <p>现在利用TypeScript的async/await语法来实现同样的功能：</p>    <pre>  <code class="language-javascript">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.entityManager.persist(photo);      console.log("Photo has been saved");    }).catch(error => console.log(error));</code></pre>    <h3>使用EntityManager</h3>    <p>刚刚我们创建了一个新的photo并且存进数据库。使用EntityManager可以操作实体，现在用 EntityManager 来把photo从数据库中取出来。</p>    <pre>  <code class="language-javascript">import {createConnection} from "typeorm";  import {Photo} from "./entity/Photo";    createConnection(/*...*/).then(async connection => {        /*...*/      let savedPhotos = await connection.entityManager.find(Photo);      console.log("All photos from the db: ", savedPhotos);    }).catch(error => console.log(error));</code></pre>    <p>savedPhotos 会从数据库中取到的是一个Photo对象的数组</p>    <h3>使用Repositories</h3>    <p>现在重构下代码，使用 Repository 来代替EntityManage。每个实体都有自己的repository，可以对这个实体进行任何操作。</p>    <p>如果要对实体做很多操作，Repositories会比EntityManager更加方便。</p>    <pre>  <code class="language-javascript">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.persist(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));</code></pre>    <h3>从数据库中取photos</h3>    <p>现在来尝试用Repository做一些取数据方面的操作:</p>    <pre>  <code class="language-javascript">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.findOneById(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: ", allPublishedPhotos);      console.log("Photos count: ", allPublishedPhotos);    }).catch(error => console.log(error));</code></pre>    <h3>更新photo</h3>    <p>现在来从数据库中取出一个photo，修改并更新到数据库。</p>    <pre>  <code class="language-javascript">import {createConnection} from "typeorm";  import {Photo} from "./entity/Photo";    createConnection(/*...*/).then(async connection => {        /*...*/      let photoToUpdate = await photoRepository.findOneById(1);      photoToUpdate.name = "Me, my friends and polar bears";      await photoRepository.persist(photoToUpdate);    }).catch(error => console.log(error));</code></pre>    <p>这个 id = 1 的photo在数据库中就成功更新了.</p>    <h3>删除photo</h3>    <p>再来，从数据库中删除我们的photo:</p>    <pre>  <code class="language-javascript">import {createConnection} from "typeorm";  import {Photo} from "./entity/Photo";    createConnection(/*...*/).then(async connection => {        /*...*/      let photoToRemove = await photoRepository.findOneById(1);      await photoRepository.remove(photoToRemove);    }).catch(error => console.log(error));</code></pre>    <p>这个 id = 1 的photo就在数据库中被移除了。</p>    <h3>一对一关系</h3>    <p>来创建与另一个类的一对一关系。</p>    <p>新建PhotoMetadata.ts用来存photo的元信息。</p>    <pre>  <code class="language-javascript">import {Table, Column, PrimaryGeneratedColumn, OneToOne, JoinColumn} from "typeorm";  import {Photo} from "./Photo";    @Table()  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;  }</code></pre>    <p>这里我们用到了一个新的装饰器 @OneToOne ，它可以用来在两个实体之间创建一对一关系。</p>    <p>type => Photo 指示了我们想要连接的实体类名，这里因为TypeScript语言的支持原因不能直接用类名。</p>    <p>当然也可以使用 () => Photo ，但是 type => Photo 显得更有可读性。</p>    <p>Type变量本身并不包含任何东西。</p>    <p>我们同样使用了 @JoinColumn 装饰器，这个装饰器可以指定一对一关系的拥有者。</p>    <p>关系可以是单向的或双向的，但是只有一方是拥有者，加个这个装饰器就表示关系是给这个表服务的。</p>    <p>现在运行app，会新创建一个table，这个table有一个连接photo的外键：</p>    <pre>  <code class="language-javascript">+-------------+--------------+----------------------------+  |                      photo `译者注：应该是PhotoMetadata` |  +-------------+--------------+----------------------------+  | id          | int(11)      | PRIMARY KEY AUTO_INCREMENT |  | height      | int(11)      |                            |  | width       | int(11)      |                            |  | comment     | varchar(255) |                            |  | compressed  | boolean      |                            |  | orientation | varchar(255) |                            |  | photo       | int(11)      | FOREIGN KEY                |  +-------------+--------------+----------------------------+</code></pre>    <h3>存一个有一对一关系的对象</h3>    <p>现在来创建一个photo，一个photo的元信息，并把它们已经连接起来。</p>    <pre>  <code class="language-javascript">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.persist(photo);        // photo存完了，再存下photo的元信息      await metadataRepository.persist(metadata);        // 搞定      console.log("metadata is saved, and relation between metadata and photo is created in the database too");    }).catch(error => console.log(error));</code></pre>    <h3>双向关系</h3>    <p>关系可以是单向的或是双向的.</p>    <p>现在PhotoMetadata和Photo的关系是单向的，关系拥有者是PhotoMetadata，Photo并不知道PhotoMetadata，这样如果要想从Photo里得到PhotoMetadata的数据会比较麻烦。</p>    <p>现在来改变一下，把单向改成双向：</p>    <pre>  <code class="language-javascript">import {Table, Column, PrimaryGeneratedColumn, OneToOne, JoinColumn} from "typeorm";  import {Photo} from "./Photo";    @Table()  export class PhotoMetadata {        /* ... 其他列 */        @OneToOne(type => Photo, photo => photo.metadata)      @JoinColumn()      photo: Photo;  }</code></pre>    <pre>  <code class="language-javascript">import {Table, Column, PrimaryGeneratedColumn, OneToOne} from "typeorm";  import {PhotoMetadata} from "./PhotoMetadata";    @Table()  export class Photo {        /* ... 其他列 */        @OneToOne(type => PhotoMetadata, photoMetadata => photoMetadata.photo)      metadata: PhotoMetadata;  }</code></pre>    <p>photo => photo.metadata 是用来指定反向关系的字段名字，photo.metadata就指出了Photo里的metadata字段名字。</p>    <p>当然也可以使用 @OneToOne('metadata') 来达到同样的目的，不过这种对于以后的代码重构不友好。</p>    <p>按上面说的， @JoinColumn 只能在关系的一边使用来使这边做为关系的拥有者，关系拥有者在数据库里的表现就是拥有一个外键列。</p>    <h3>取出关系对象的数据</h3>    <p>现在来用一个查询来取出photo以及它的元信息。</p>    <p>有两种方式，一是用 FindOptions ，另一个是使用 QueryBuilder 。</p>    <p>先试下 FindOptions ，通过指定 FindOptions 接口作为参数来使用 Repository.find 方法可以完成非常复杂的查询。</p>    <pre>  <code class="language-javascript">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({          alias: "photo",          innerJoinAndSelect: {              "metadata": "photo.metadata"          }      });      }).catch(error => console.log(error));</code></pre>    <p>返回的photos是从数据库里取回的photo的数组，每个photo都包含它的元信息。</p>    <p>alias 是FindOptions的一个必需选项，这是你自己在select里定义的别名，然后需要用在接下来的 where, order by, group by, join 以及其他表达式.</p>    <p>这里还用到了 innerJoinAndSelect ，表示内联查询photo.metadata的数据。</p>    <p>"photo.metadata" 里"photo"是一个别名，"metadata"则是你想查询的那个对象的属性名。</p>    <p>"metadata" : 是内联返回数据的新的别名.</p>    <p>下面来尝试第二种方式： QueryBuilder 来达到同样的目的. 使用 QueryBuilder 可以优雅完成复杂的查询:</p>    <pre>  <code class="language-javascript">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.createQueryBuilder("photo")              .innerJoinAndSelect("photo.metadata", "metadata")              .getMany();      }).catch(error => console.log(error));</code></pre>    <h3>使用 cascade 选项来自动保存关系着的对象</h3>    <p>上面要保存关系对象需要一个一个来保存，略显麻烦。</p>    <p>如果我们需要当关系对象中的一个被保存后，另一个也同样被保存，则可以使用 cascade 选项来做到。</p>    <p>稍微改下 @OneToOne 装饰:</p>    <pre>  <code class="language-javascript">export class Photo {      /// ... 其他列        @OneToOne(type => PhotoMetadata, metadata => metadata.photo, {          cascadeInsert: true,          cascadeUpdate: true,          cascadeRemove: true      })      metadata: PhotoMetadata;  }</code></pre>    <ul>     <li><strong>cascadeInsert</strong> - 如果表中没有关系中的metadata，则自动insert，即我们不需要再手动insert一个新的photoMetadata对象。</li>     <li><strong>cascadeUpdate</strong> - 如果metadata有变化，则自动update。</li>     <li><strong>cascadeRemove</strong> - 如果把photo里的metadata移除了，也就是为空，则会自动remove表中的这条metadata数据。</li>    </ul>    <p>使用cascadeInsert就可以不需要像上面那边先存photo再存metadata了。</p>    <p>现在我们来单单存photo对象，由于cascade的作用，metadata也会自动存上。</p>    <pre>  <code class="language-javascript">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.persist(photo);      // photo metadata也自动存上了      console.log("Photo is saved, photo metadata is saved too.")    }).catch(error => console.log(error));</code></pre>    <h3>多对一/一对多关系</h3>    <p>接下来显示多对一/一对多关系。</p>    <p>假设一个photo会有一个author，并且每个author可以有很多photo。</p>    <p>先创建Author实体：</p>    <pre>  <code class="language-javascript">import {Table, Column, PrimaryGeneratedColumn, OneToMany, JoinColumn} from "typeorm";  import {Photo} from "./Photo";    @Table()  export class Author {        @PrimaryGeneratedColumn()      id: number;        @Column()      name: string;        @OneToMany(type => Photo, photo => photo.author) // 备注：下面会为Photo创建author属性      photos: Photo[];  }</code></pre>    <p>Author包含一个反向的关系， OneToMany 总是反向的，并且总是与 ManyToOne 成对出现。</p>    <p>现在来为Photo加上关系拥有者。</p>    <pre>  <code class="language-javascript">import {Table, Column, PrimaryGeneratedColumn, ManyToOne} from "typeorm";  import {PhotoMetadata} from "./PhotoMetadata";  import {Author} from "./Author";    @Table()  export class Photo {        /* ... 其他列 */        @ManyToOne(type => Author, author => author.photos)      author: Author;  }</code></pre>    <p>在 ManyToOne/OneToMany 关系中，拥有者一边总是 ManyToOne 。 译者注：拥有外键者即关系拥有者<br> 也就是 ManyToOne 的那个字段存的是另一个对象的id。 译者注：也就是上面的author虽然属性是Author，但在数据库中类型是Author id的类型，存的也是id</p>    <p>执行上面的代码将会自动创建author表，如下:</p>    <pre>  <code class="language-javascript">+-------------+--------------+----------------------------+  |                          author                         |  +-------------+--------------+----------------------------+  | id          | int(11)      | PRIMARY KEY AUTO_INCREMENT |  | name        | varchar(255) |                            |  +-------------+--------------+----------------------------+</code></pre>    <p>因为photo表已经存在，所以不是增加而是修改photo表 - 添加一个新外键列author:</p>    <pre>  <code class="language-javascript">+-------------+--------------+----------------------------+  |                         photo                           |  +-------------+--------------+----------------------------+  | id          | int(11)      | PRIMARY KEY AUTO_INCREMENT |  | name        | varchar(255) |                            |  | description | varchar(255) |                            |  | filename    | varchar(255) |                            |  | isPublished | boolean      |                            |  | author      | int(11)      | FOREIGN KEY                |  +-------------+--------------+----------------------------+</code></pre>    <h3>多对多关系</h3>    <p>假设photo可以存在多个相册中，并且相册里可以包含多个photo。</p>    <p>先创建一个 Album 类</p>    <pre>  <code class="language-javascript">import {Table, PrimaryGeneratedColumn, Column, ManyToMany, JoinTable} from "typeorm";    @Table()  export class Album {        @PrimaryGeneratedColumn()      id: number;        @Column()      name: string;        @ManyToMany(type => Photo, photo => photo.albums, {  // 备注: 会在下面的Photo类里添加"albums"属性          cascadeInsert: true, // 在添加Album时，会自动添加相册里的Photo          cascadeUpdate: true, // 在更新Album时，会自动更新相册里的Photo           cascadeRemove: true  // 在移除Album时，会自动移除相册里的Photo      })      @JoinTable()      photos: Photo[] = []; // 初始化个Photo数组  }</code></pre>    <p>@JoinTable 多对多关系拥有者必须指定的。</p>    <p>接着给 Photo 实体加个反向关系:</p>    <pre>  <code class="language-javascript">export class Photo {      /// ... 其他列        @ManyToMany(type => Album, album => album.photos, {          cascadeInsert: true, // 在添加Album时，会自动添加相册里的Photo          cascadeUpdate: true, // 在更新Album时，会自动更新相册里的Photo           cascadeRemove: true  // 在移除Album时，会自动移除相册里的Photo      })      albums: Album[] = []; // 初始化个Album数组  }</code></pre>    <p>执行上面的代码后会自动创建一个叫 <strong>album_photos_photo_albums</strong> 的 <em>联接表</em> :</p>    <pre>  <code class="language-javascript">+-------------+--------------+----------------------------+  |                album_photos_photo_albums                |  +-------------+--------------+----------------------------+  | album_id_1  | int(11)      | PRIMARY KEY FOREIGN KEY    |  | photo_id_2  | int(11)      | PRIMARY KEY FOREIGN KEY    |  +-------------+--------------+----------------------------+</code></pre>    <p>记得把 Album 实体加到ConnectionOptions中:</p>    <pre>  <code class="language-javascript">const options: CreateConnectionOptions = {      // ... 其他配置      entities: [Photo, PhotoMetadata, Author, Album]  };</code></pre>    <p>现在来往数据库里插入albums和photos</p>    <pre>  <code class="language-javascript">let connection = await createConnection(options);    // 创建两个albums  let album1 = new Album();  album1.name = "Bears";    let album2 = new Album();  album2.name = "Me";    // 创建两个photos  let photo1 = new Photo();  photo1.name = "Me and Bears";  photo1.description = "I am near polar bears";  photo1.filename = "photo-with-bears.jpg";  photo1.albums.push(album1);    let photo2 = new Photo();  photo2.name = "Me and Bears";  photo2.description = "I am near polar bears";  photo2.filename = "photo-with-bears.jpg";  photo2.albums.push(album2);    // 获取Photo的repository  let photoRepository = connection.getRepository(Photo);    // 依次存储photos，由于cascade，albums也同样会自动存起来  await photoRepository.persist(photo1);  await photoRepository.persist(photo2);    console.log("Both photos have been saved");</code></pre>    <h3>使用QueryBuilder</h3>    <p>可以利用QueryBuilder来构建一个非常复杂的查询，例如：</p>    <pre>  <code class="language-javascript">let photoRepository = connection.getRepository(Photo);  let photos = await photoRepository      .createQueryBuilder("photo") // 别名，必填项，用来指定本次查询      .innerJoinAndSelect("photo.metadata", "metadata")      .leftJoinAndSelect("photo.albums", "albums")      .where("photo.isPublished=true")      .andWhere("(photo.name=:photoName OR photo.name=:bearName)")      .orderBy("photo.id", "DESC")      .setFirstResult(5)      .setMaxResults(10)      .setParameters({ photoName: "My", bearName: "Mishka" })      .getMany();</code></pre>    <p>这个查询会查找已经published的，并且name是"My"或"Mishka"，</p>    <p>得到的结果会从第5个开始（分页偏移决定的），</p>    <p>并且只会得到10个结果（分页每页个数决定的），</p>    <p>所得结果是以id的倒序排序的，</p>    <p>Photo的albums是左联接，photo的metadata是内联接。</p>    <p> </p>    <p> </p>    <p>来自：http://www.cnblogs.com/brookshi/p/6446155.html</p>    <p> </p>