实体

实体定义

实体是一个映射到数据库表（或使用MongoDB时的集合）的类。你可以通过定义一个新类来创建一个实体，并用@Entity()来标记：

@Entity()
export class User {
  @PrimaryGeneratedColumn()
  id: number;

  @Column()
  firstName: string;

  @Column()
  lastName: string;

  @Column()
  isActive: boolean;
}

这将创建以下数据库表：

+-------------+--------------+----------------------------+
|                          user                           |
+-------------+--------------+----------------------------+
| id          | int(11)      | PRIMARY KEY AUTO_INCREMENT |
| firstName   | varchar(255) |                            |
| lastName    | varchar(255) |                            |
| isActive    | boolean      |                            |
+-------------+--------------+----------------------------+

基本实体由列和关系组成。每个实体必须有一个主列（如果使用MongoDB，则为ObjectId列）。每个实体都必须在连接选项中注册：

const connection: Connection = await createConnection({
  type: "mysql",
  host: "localhost",
  port: 3306,
  username: "test",
  password: "test",
  database: "test",
  entities: [User]
  // 指定包含所有实体的整个目录，该目录下所有实体都将被加载
  // entities: ["entity/*.js"]
});

如果要为User实体使用替代表名，可以在@Entity中指定：@Entity（“my_users”）。如果要为应用程序中的所有数据库表设置基本前缀，可以在连接选项中指定entityPrefix。

实体列

由于数据库表由列组成，因此实体也必须由列组成。标有@Column的每个实体类属性都将映射到数据库表列。

主列

每个实体必须至少有一个主列。有几种类型的主要列：

@PrimaryColumn()创建一个主列，它可以获取任何类型的任何值。你也可以指定列类型。如果未指定列类型，则将从属性类型自动推断。
@PrimaryGeneratedColumn()创建一个主列，该值将使用自动增量值自动生成。它将使用auto-increment /serial /sequence创建int列（取决于数据库）。你不必在保存之前手动分配其值，该值将会自动生成。
@PrimaryGeneratedColumn(“uuid”)创建一个主列，该值将使用uuid自动生成。Uuid是一个独特的字符串id。你不必在保存之前手动分配其值，该值将自动生成。

你也可以拥有复合主列：

@Entity()
export class User {
  @PrimaryColumn()
  firstName: string;

  @PrimaryColumn()
  lastName: string;
}

当您使用save保存实体时，它总是先尝试使用给定的实体ID（或ids）在数据库中查找实体。如果找到id/ids，则将更新数据库中的这一行。如果没有包含id/ids的行，则会插入一个新行。要通过id查找实体，可以使用 manager.findOne或repository.findOne。例：

// 使用单个主键查找一个id
const person = await connection.manager.findOne(Person, 1);
const person = await connection.getRepository(Person).findOne(1);

// 使用复合主键找到一个id
const user = await connection.manager.findOne(User, {
  firstName: "Timber",
  lastName: "Saw"
});
const user = await connection
  .getRepository(User)
  .findOne({ firstName: "Timber", lastName: "Saw" });

列类型

TypeORM支持所有最常用的数据库支持的列类型。列类型是特定于数据库类型的-这为数据库架构提供了更大的灵活性。你可以将列类型指定为@ Column的第一个参数或者在@Column的列选项中指定，例如：

@Column("int")

@Column({ type: "int" })

@Column("varchar", { length: 200 })

@Column({ type: "int", length: 200 })

mysql/mariadb的列类型: int, tinyint, smallint, mediumint, bigint, float, double, dec, decimal, numeric, date, datetime, timestamp, time, year, char, varchar, nvarchar, text, tinytext, mediumtext, blob, longtext, tinyblob, mediumblob, longblob, enum, json, binary, geometry, point, linestring, polygon, multipoint, multilinestring, multipolygon, geometrycollection

有几种特殊的列类型可以使用：

@CreateDateColumn是一个特殊列，自动为实体插入日期。无需设置此列，该值将自动设置。
@UpdateDateColumn是一个特殊列，在每次调用实体管理器或存储库的save时，自动更新实体日期。无需设置此列，该值将自动设置。
@VersionColumn是一个特殊列，在每次调用实体管理器或存储库的save时自动增长实体版本（增量编号）。无需设置此列，该值将自动设置。

enum列类型

postgres和mysql都支持enum列类型。并有多种列定义方式：

// 使用 typescript 枚举
export enum UserRole {
  ADMIN = "admin",
  EDITOR = "editor",
  GHOST = "ghost"
}

@Entity()
export class User {
  @PrimaryGeneratedColumn()
  id: number;

  @Column({
    type: "enum",
    enum: UserRole,
    default: UserRole.GHOST
  })
  role: UserRole;
}

// 使用带枚举值的数组
export type UserRoleType = "admin" | "editor" | "ghost",

@Entity()
export class User {

    @PrimaryGeneratedColumn()
    id: number;

    @Column({
        type: "enum",
        enum: ["admin", "editor", "ghost"],
        default: "ghost"
    })
    role: UserRoleType
}

simple-array的列类型

有一种称为simple-array的特殊列类型，它可以将原始数组值存储在单个字符串列中。所有值都以逗号分隔。例如：

@Entity()
export class User {
  @PrimaryGeneratedColumn()
  id: number;

  @Column("simple-array")
  names: string[];
}

const user = new User();
user.names = ["Alexander", "Alex", "Sasha", "Shurik"];

存储在单个数据库列中的Alexander，Alex，Sasha，Shurik值。当你从数据库加载数据时，name将作为names数组返回，就像之前存储它们一样。

simple-json列类型

还有一个名为simple-json的特殊列类型，它可以存储任何可以通过JSON.stringify存储在数据库中的值当你的数据库中没有json类型而你又想存储和加载对象，该类型就很有用了例如:

@Entity()
export class User {
  @PrimaryGeneratedColumn()
  id: number;

  @Column("simple-json")
  profile: { name: string; nickname: string };
}
const user = new User();
user.profile = { name: "John", nickname: "Malkovich" };

存储在单个数据库列中的{“name”：“John”，“nickname”：“Malkovich”}值当你从数据库加载数据时，将通过JSON.parse返回object/array/primitive。

嵌入式实体

通过使用embedded columns，可以减少应用程序中的重复（使用组合而不是继承）。嵌入列是一个列，它接受具有自己列的类，并将这些列合并到当前实体的数据库表中。例如:假设我们有User，Employee和Student实体。这些属性都有少量的共同点，first name和last name属性。我们可以做的是通过创建一个包含firstName和lastName的新类：

import { Entity, Column } from "typeorm";

export class Name {
  @Column()
  first: string;

  @Column()
  last: string;
}

然后"connect"实体中的这些列：

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

@Entity()
export class User {
  @PrimaryGeneratedColumn()
  id: string;

  @Column(type => Name)
  name: Name;

  @Column()
  isActive: boolean;
}

Name实体中定义的所有列将合并为user，employee和student：

+-------------+--------------+----------------------------+
|                          user                           |
+-------------+--------------+----------------------------+
| id          | int(11)      | PRIMARY KEY AUTO_INCREMENT |
| nameFirst   | varchar(255) |                            |
| nameLast    | varchar(255) |                            |
| isActive    | boolean      |                            |
+-------------+--------------+----------------------------+

实体继承

你可以使用实体继承模式减少代码中的重复最简单和最有效的是具体的表继承。所有这些实体都有共同的列：id，title，description为了减少重复并产生更好的抽象，我们可以为它们创建一个名为 Content 的基类：

export abstract class Content {
  @PrimaryGeneratedColumn()
  id: number;

  @Column()
  title: string;

  @Column()
  description: string;
}

@Entity()
export class Photo extends Content {
  @Column()
  size: string;
}

最近更新于0001-01-01