2021-11-26

作者: 李留白 | 来源:发表于2021-11-26 15:18 被阅读0次

PHP把html转为图片
亲子阅读篇（三十九）《狮子
《金吾生〈正蒙〉日记506.2021-11-26》
开始吧
2021-11-26*2
2021-11-26 周五
No 261 多少个不舍，不一样都过来了？
2021-11-26武则天《升仙太子碑》原文
彩妆小课堂

原文： https://www.jianshu.com/p/0fcf45030dd4

实体

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

@Entity()
export class User {

    @PrimaryGeneratedColumn()  // 自增主键
    id: number;

    @Column({ comment: '性别', type: 'enum', enum: SexRole, default: SexRole.BOY })  // 枚举
     sex: SexRole

    @Column("simple-array")  // 数组
    names: string[];

   @Column("simple-json")  // 对象
    profile: { name: string; nickname: string };

    @Column({unique:true})  // 唯一
    @Generated("uuid") // 自动生成列
    token: string;

    @Column()
    firstName: string;

    @Column()
    lastName: string;

    @Column()
    age: number;

@CreateDateColumn({ comment: '创建时间' })  // 自动生成列
  createdAt: string

  @UpdateDateColumn({ comment: '更新时间' })   // 自动生成并自动更新列
  updatedAt: string
}

关系

1、一对一
一对一是一种 A 只包含一个 B 实例，而 B 只包含一个 A 实例的关系

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

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

  @Column()
  gender: string;

  @Column()
  photo: string;

  @OneToOne(type => User, user => user.profile) // 将另一面指定为第二个参数
  user: User;
}
import { Entity, PrimaryGeneratedColumn, Column, OneToOne, JoinColumn } from "typeorm";
import { Profile } from "./Profile";

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

  @Column()
  name: string;

  @OneToOne(type => Profile, profile => profile.user，{cascade:true}) // 指定另一面作为第二个参数
  @JoinColumn()
  profile: Profile;
}

表 user 中，将新增一个 profileId 字段指向 profile 表中的 id 字段；
表 profile中，不会新增 userId 字段
要加载带有 user 的 profile，必须在FindOptions中指定关系

const profileRepository = connection.getRepository(Profile);
const profiles= await profileRepository .find({ relations: ["user"] });

// or from inverse side
const userRepository = connection.getRepository(User);
const users = await userRepository .find({ relations: ["profile"] });

2、多对一/一对多
多对一/一对多是指 A 包含多个 B 实例的关系，但 B 只包含一个 A 实例

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

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

  @Column()
  url: string;

  @ManyToOne(type => User, user => user.photos，{cascade:true})
  user: User;
}
import { Entity, PrimaryGeneratedColumn, Column, OneToMany } from "typeorm";
import { Photo } from "./Photo";

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

  @Column()
  name: string;

  @OneToMany(type => Photo, photo => photo.user，{cascade:true})
  photos: Photo[];
}

设置@ManyToOne的地方，相关实体将有"关联 id"和外键
表 photo中，将新增一个 userId 字段指向 user 表中的 id 字段；
表 user 中，不会新增 photos 字段
要加载带有 photos 的 user，必须在FindOptions中指定关系

const userRepository = connection.getRepository(User);
const users = await userRepository.find({ relations: ["photos"] });

// or from inverse side
const photoRepository = connection.getRepository(Photo);
const photos = await photoRepository.find({ relations: ["user"] });

3、多对多
多对多是一种 A 包含多个 B 实例，而 B 包含多个 A 实例的关系

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

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

  @Column()
  name: string;

  @ManyToMany(type => Question, question => question.categories)
  questions: Question[];
}
import { Entity, PrimaryGeneratedColumn, Column, ManyToMany, JoinTable } from "typeorm";
import { Category } from "./Category";

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

  @Column()
  title: string;

  @Column()
  text: string;

  @ManyToMany(type => Category, category => category.questions)
  @JoinTable()
  categories: Category[];
}

@JoinTable()是@ManyToMany关系所必需的。你必须把@JoinTable放在关系的一个（拥有）方面
会生成三个表：

image

增删改查

const user = new User();
user.firstName = "Timber";
user.lastName = "Saw";
user.age = 25;
//  保存
await repository.save(user);
// 查找所有
const allUsers = await repository.find();
// 按id查找
const firstUser = await repository.findOne(1);
// 按条件查找一个
const timber = await repository.findOne({ firstName: "Timber", lastName: "Saw" });
// 关系查找(查找和该表关联的值)
const questions = await questionRepository.find({ relations: ["categories"] });
// 查找并计数
const count = await repository.findAndCount();
// 删除
await repository.remove(timber);

复杂查询

// 1、find 操作
userRepository.find({
    select: ["firstName", "lastName"],               // 按属性查找
    relations: ["profile", "photos", "videos"],      // 按关系查找
    where: {                                                      // 条件查询
        firstName: "Timber",
        lastName: "Saw"
    },                                                                 // 排序
    order: {
        name: "ASC",
        id: "DESC"
    },
    skip: 5,     // 分页，跳过几项
    take: 10,  // 分页，取几项
    cache: true
});

// 2、内置运算符查询（Not，LessThan，Equal，Like 等）

import { Like } from "typeorm";
const loadedPosts = await connection.getRepository(Post).find({
    title: Like("%out #%")    // 模糊查询，%表示任何字符出现任意次数 (可以是0次)，_只能匹配单个字符,不能多也不能少,就是一个字符
});