Sequelize

MySQL

model

  1. 'use strict';
  2. const moment = require('moment');//  日期处理模块
  3. module.exports = app => {
  5.   const Instance = app.model.define('test', {
  6.     id: {
  7.       /**
  8.        * ! 数据类型
  9.        * ?
  10.        * STRING     字符串
  11.        *
  12.        * DOUBLE     0 1 double
  13.        *
  14.        * *&*********日期
  15.        * DATE       DATETIME 适用于 mysql / sqlite, 带时区的TIMESTAMP 适用于 postgres
  16.        * DATE(6)    DATETIME(6) 适用于 mysql 5.6.4+. 支持6位精度的小数秒
  17.        * DATEONLY   不带时间的 DATE
  18.        *
  19.        * *&*********数字
  20.        * INTEGER    integer
  21.        * FLOAT      float
  22.        * REAL       real
  23.        * DOUBLE     double
  24.        *
  25.        */
  26.       type: app.Sequelize.INTEGER(5),
  27.       primaryKey: true, // 住建
  28.       autoIncrement: true, // 自增
  29.       unique: true, // 唯一
  30.       allowNull: true, // 不允许为空
  31.       description: '唯一标识', // 描述
  32.       defaultValue: 10000, // 默认值
  33.     //   comment: '这是带有注释的列', //额外的注释
  34.     },
  36.     // 日期的默认值 => 当前时间
  37.     //   myDate: { type: DataTypes.DATE, defaultValue: DataTypes.NOW },
  39.     // 创建时间 修改时间 格式化
  40.     createdAt: { type: app.Sequelize.DATE, get() { return moment(this.getDataValue('created_at')).format('YYYY-MM-DD HH:mm:ss'); } },
  41.     updatedAt: { type: app.Sequelize.DATE, get() { return moment(this.getDataValue('updated_at')).format('YYYY-MM-DD HH:mm:ss'); } },
  42.   }, {
  44.     // comment: '实例', // 表注释
  45.     // modelName: 'tablename', // 定义表名
  46.     // 在上面的属性中使用 `unique: true` 与在模型的参数中创建索引完全相同：
  47.     indexes: [
  48.       {
  49.         unique: true,
  50.         fields: [ 'id' ], // 唯一约束
  51.       },
  52.     ],
  54.   });
  55.   // 外键约束
  56.   Instance.associate = function() {
  57.     // 一对一
  58.     // app.model.Stores.Type.belongsTo(app.model.Managers.User, { foreignKey: 'author', targetKey: 'id' });
  60.     // 一对多
  61.     // app.model.Answer.Content.hasMany(app.model.Answer.Options, { foreignKey: 'answerId', targetKey: 'id' });
  62.     // app.model.Answer.Options.belongsTo(app.model.Answer.Content, { foreignKey: 'answerId', targetKey: 'id' });
  65.   };
  66.   return Instance;
  67. };

controller

  1. 'use strict';
  3. const Controller = require('egg').Controller;
  4. const Sequelize = require('sequelize');
  5. const Op = Sequelize.Op;
  8. // 全局变量
  9. const tableName = 'TableName';
  12. // 数据库模块 名称
  13. const models = {
  14.   modelGroup: 'ModelGroup',
  15.   modelName: 'ModelName',
  16. };
  18. // 定义创建接口的请求参数规则
  19. const createRule = {
  20.   // username: {
  21.   //   type: 'userName', // type -属性的类型，每种类型都有自己的验证规则。
  22.   // 如果required设置为false，则此属性可以为null或未定义。默认为true
  23.   // convertType-使参数转换的输入参数的具体类型，支持int，number，string和boolean，还支持功能，定制自己的转换方法。
  24.   // default-属性的默认值，一旦允许该属性为非必需和丢失的，则参数将使用该默认值。这可能会更改原始的输入参数。
  25.   // },
  26. };
  28. //  定义修改接口的请求参数规则
  29. const updateRule = {
  30.   //   id: { type: 'Id' },
  31. };
  34. class TestController extends Controller {
  35.   /**
  36.    * @description 查询数据
  37.    */
  38.   async index() {
  39.     // 分页参数
  40.     const pagedata = {
  41.       page: this.ctx.query.page,
  42.       limit: this.ctx.query.rows,
  43.     };
  44.     const pageNumber = this.ctx.helper.pageNumber(pagedata);
  45.     const search = this.ctx.query.search || ''; // 搜索内容
  46.     const find = await this.ctx.service.database.query.findAndCountAll({
  47.       ...models,
  48.       // 查询条件
  49.       conditions: {
  50.         ...pageNumber,
  51.         attributes: {
  52.           // 排除 查询字段
  53.           exclude: [ 'updated_at', 'deleted_at', 'created_at' ],
  54.           include: [
  55.             // 字段 修改名称
  56.             [ Sequelize.col('created_at'), 'createdTime' ],
  57.           ],
  58.         },
  59.         order: [ // id倒叙
  60.           [ 'id', 'DESC' ],
  61.         ],
  62.         include: [
  63.           // 关联 表
  64.         ],
  65.         //  查询 条件
  66.         // WHERE
  67.         where: {
  68.           name: { // TODO
  69.             [Op.like]: `%${search}%`,
  70.             // [Op.and]: {a: 5}           // 且 (a = 5)
  71.             // [Op.or]: [{a: 5}, {a: 6}]  // (a = 5 或 a = 6)
  72.             // [Op.gt]: 6,                // id > 6
  73.             // [Op.gte]: 6,               // id >= 6
  74.             // [Op.lt]: 10,               // id < 10
  75.             // [Op.lte]: 10,              // id <= 10
  76.             // [Op.ne]: 20,               // id != 20
  77.             // [Op.eq]: 3,                // = 3
  78.             // [Op.not]: true,            // 不是 TRUE
  79.             // [Op.between]: [6, 10],     // 在 6 和 10 之间
  80.             // [Op.notBetween]: [11, 15], // 不在 11 和 15 之间
  81.             // [Op.in]: [1, 2],           // 在 [1, 2] 之中
  82.             // [Op.notIn]: [1, 2],        // 不在 [1, 2] 之中
  83.             // [Op.like]: '%hat',         // 包含 '%hat'
  84.             // [Op.notLike]: '%hat'       // 不包含 '%hat'
  85.             // [Op.iLike]: '%hat'         // 包含 '%hat' (不区分大小写)  (仅限 PG)
  86.             // [Op.notILike]: '%hat'      // 不包含 '%hat'  (仅限 PG)
  87.             // [Op.startsWith]: 'hat'     // 类似 'hat%'
  88.             // [Op.endsWith]: 'hat'       // 类似 '%hat'
  89.             // [Op.substring]: 'hat'      // 类似 '%hat%'
  90.             // [Op.regexp]: '^[h|a|t]'    // 匹配正则表达式/~ '^[h|a|t]' (仅限 MySQL/PG)
  91.             // [Op.notRegexp]: '^[h|a|t]' // 不匹配正则表达式/!~ '^[h|a|t]' (仅限 MySQL/PG)
  92.             // [Op.iRegexp]: '^[h|a|t]'    // ~* '^[h|a|t]' (仅限 PG)
  93.             // [Op.notIRegexp]: '^[h|a|t]' // !~* '^[h|a|t]' (仅限 PG)
  94.             // [Op.like]: { [Op.any]: ['cat', 'hat']} // 包含任何数组['cat', 'hat'] - 同样适用于 iLike 和 notLike
  95.             // [Op.overlap]: [1, 2]       // && [1, 2] (PG数组重叠运算符)
  96.             // [Op.contains]: [1, 2]      // @> [1, 2] (PG数组包含运算符)
  97.             // [Op.contained]: [1, 2]     // <@ [1, 2] (PG数组包含于运算符)
  98.             // [Op.any]: [2,3]            // 任何数组[2, 3]::INTEGER (仅限PG)
  99.             // [Op.col]: 'user.organization_id' // = 'user'.'organization_id', 使用数据库语言特定的列标识符, 本例使用 PG
  100.           },
  101.         },
  102.       },
  103.     });
  104.     this.ctx.body = await this.ctx.helper.outputJSON({ data: { ...find }, msg: `${tableName}信息成功` });
  105.   }
  106.   /**
  107.    * @description 创建数据
  108.    */
  109.   async create() {
  110.     const data = this.ctx.request.body;
  111.     data.author = await this.ctx.managers.id;
  112.     this.ctx.validate(createRule, this.ctx.request.body);
  113.     const creat = await this.ctx.service.database.create.create({
  114.       ...models,
  115.       data,
  116.     });
  117.     this.ctx.body = await this.ctx.helper.outputJSON({ data: creat, msg: `${tableName}创建成功` });
  118.   }
  120.   /**
  121.    * @description 更新数据
  122.    */
  123.   async update() {
  124.     try {
  125.       this.ctx.validate(updateRule, this.ctx.request.body);
  126.       const retdata = await this.ctx.service.database.update.update({
  127.         ...models,
  128.         data: {
  129.           // TODO 修改字段
  130.           // TODO UPDATA
  131.           //  name: this.ctx.request.body.name,
  132.         },
  133.         id: this.ctx.helper.parseInt(this.ctx.params.id),
  134.       });
  135.       const res = retdata ? await this.ctx.helper.outputJSON({ msg: `${tableName}信息修改` }) : await this.ctx.helper.outputErrJSON({ msg: '没有找到修改的内容' });
  136.       this.ctx.body = await res;
  137.       return;
  138.     } catch (error) {
  139.       this.ctx.body = await this.ctx.helper.outputErrJSON({ msg: '出现错误' });
  140.       return;
  141.     }
  142.   }
  144.   /**
  145.    * @description 删除数据
  146.   */
  147.   async destroy() {
  148.     const data = await this.ctx.service.database.query.findByPk({ id: this.ctx.helper.parseInt(this.ctx.params.id), ...models });
  149.     if (!data) {
  150.       this.ctx.body = await this.ctx.helper.outputErrJSON({ msg: '没有找到要删除的内容' });
  151.       return;
  152.     }
  153.     await this.service.database.destroy.destroy({ id: this.ctx.helper.parseInt(this.ctx.params.id), ...models });
  154.     this.ctx.body = await this.ctx.helper.outputJSON({ msg: `${tableName}已删除` });
  155.   }
  156. }
  158. module.exports = TestController;

sequelizerc

文档

安装

  1. npm install --save-dev sequelize-cli

配置

  1. // .sequelizerc 
  2. 'use strict';
  4. const path = require('path');
  6. module.exports = {
  7.   config: path.join(__dirname, 'database/config.json'),
  8.   'migrations-path': path.join(__dirname, 'database/migrations'),
  9.   'seeders-path': path.join(__dirname, 'database/seeders'),
  10.   'models-path': path.join(__dirname, 'app/model'),
  11. };

初始化 Migrations 配置文件和目录

  1. npx sequelize init:config
  2. npx sequelize init:migrations
  3. npx sequelize init
  1. ###  迁移
  2. (文档)[https://github.com/demopark/sequelize-docs-Zh-CN/blob/v5/migrations.md]
  4. 1. 安装 sequelize-cli
  5. npm install --save-dev sequelize-cli
  7. 2. .sequelizerc 配置文件
  10. ``` .sequelizerc
  11. 'use strict';
  13. const path = require('path');
  15. module.exports = {
  16.   config: path.join(__dirname, 'database/config.json'),
  17.   'migrations-path': path.join(__dirname, 'database/migrations'),
  18.   'seeders-path': path.join(__dirname, 'database/seeders'),
  19.   'models-path': path.join(__dirname, 'app/model'),
  20. };
  1. 初始化 Migrations 配置文件和目录

npx sequelize init:config npx sequelize init:migrations npx sequelize init

  1. config, 包含配置文件,它告诉CLI如何连接数据库
  2. models,包含你的项目的所有模型
  3. migrations, 包含所有迁移文件
  4. seeders, 包含所有种子文件
  1. 将其改成我们项目中使用的数据库配置
  2.   "development": {
  3.     "username": "root", 
  4.     "password": null,
  5.     "database": "egg-sequelize-doc-default", // 数据库
  6.     "host": "127.0.0.1", // 地址
  7.     "dialect": "mysql" // 数据库类型  
  8.   },
  1. 此时 sequelize-cli 和相关的配置也都初始化好了，我们可以开始编写项目的第一个 Migration 文件来创建我们的一个 users 表了 npx sequelize migration:generate —name=init-users

npx sequelize migration:generate —name User —attributes firstName:string,lastName:string,email:string

如果你的数据库还不存在,你可以调用 db:create 命令. 通过正确的访问,它将为你创建该数据库.

  1. 添加字段
  1. 'use strict';
  3. module.exports = {
  4.   // 在执行数据库升级时调用的函数，创建 users 表
  5.   up: async (queryInterface, Sequelize) => {
  6.     const { INTEGER, DATE, STRING } = Sequelize;
  7.     await queryInterface.createTable('users', {
  8.       id: { type: INTEGER, primaryKey: true, autoIncrement: true },
  9.       name: STRING(30),
  10.       age: INTEGER,
  11.       created_at: DATE,
  12.       updated_at: DATE,
  13.     });
  14.   },
  15.   // 在执行数据库降级时调用的函数，删除 users 表
  16.   down: async queryInterface => {
  17.     await queryInterface.dropTable('users');
  18.   },
  19. };
  1. 执行 migrate 进行数据库变更 ```

    升级数据库

    npx sequelize db:migrate

    如果有问题需要回滚，可以通过 db:migrate:undo 回退一个变更

    npx sequelize db:migrate:undo

    可以通过 db:migrate:undo:all 回退到初始状态

    npx sequelize db:migrate:undo:all

  2. 8.  编写model
  5. ``` js
  6. 'use strict';
  8. module.exports = app => {
  9.   const { STRING, INTEGER, DATE } = app.Sequelize;
  10.   const User = app.model.define('user', {
  11.     id: { type: INTEGER, primaryKey: true, autoIncrement: true },
  12.     name: STRING(30),
  13.     age: INTEGER,
  14.     created_at: DATE,
  15.     updated_at: DATE,
  16.   });
  17.   return User;
  18. };
  1. 访问model
  1. // app/controller/users.js
  2. const Controller = require('egg').Controller;
  4. function toInt(str) {
  5.   if (typeof str === 'number') return str;
  6.   if (!str) return str;
  7.   return parseInt(str, 10) || 0;
  8. }
  10. class UserController extends Controller {
  11.   async index() {
  12.     const ctx = this.ctx;
  13.     const query = { limit: toInt(ctx.query.limit), offset: toInt(ctx.query.offset) };
  14.     ctx.body = await ctx.model.User.findAll(query);
  15.   }
  17.   async show() {
  18.     const ctx = this.ctx;
  19.     ctx.body = await ctx.model.User.findByPk(toInt(ctx.params.id));
  20.   }
  22.   async create() {
  23.     const ctx = this.ctx;
  24.     const { name, age } = ctx.request.body;
  25.     const user = await ctx.model.User.create({ name, age });
  26.     ctx.status = 201;
  27.     ctx.body = user;
  28.   }
  30.   async update() {
  31.     const ctx = this.ctx;
  32.     const id = toInt(ctx.params.id);
  33.     const user = await ctx.model.User.findByPk(id);
  34.     if (!user) {
  35.       ctx.status = 404;
  36.       return;
  37.     }
  39.     const { name, age } = ctx.request.body;
  40.     await user.update({ name, age });
  41.     ctx.body = user;
  42.   }
  44.   async destroy() {
  45.     const ctx = this.ctx;
  46.     const id = toInt(ctx.params.id);
  47.     const user = await ctx.model.User.findByPk(id);
  48.     if (!user) {
  49.       ctx.status = 404;
  50.       return;
  51.     }
  53.     await user.destroy();
  54.     ctx.status = 200;
  55.   }
  56. }
  58. module.exports = UserController;
  1. 创建第一个种子
  1. npx sequelize-cli seed:generate --name managers
  3. # 同上
  4. npx sequelize seed:generate --name managers
  1. 运行种子 撤销种子
  1. # 运行种子
  2. npx sequelize-cli db:seed:all
  3. # 如果你想撤消最近的种子
  4. npx sequelize-cli db:seed:undo
  5. # 如果你想撤消特定的种子
  6. npx sequelize-cli db:seed:undo --seed name-of-seed-as-in-data
  7. # 如果你想撤消所有的种子
  8. npx sequelize-cli db:seed:undo:all

下一个是具有外键的迁移示例. 你可以使用 references 来指定外键:

  2. module.exports = {
  3.   up: (queryInterface, Sequelize) => {
  4.     return queryInterface.createTable('Person', {
  5.       name: Sequelize.STRING,
  6.       isBetaMember: {
  7.         type: Sequelize.BOOLEAN,
  8.         defaultValue: false,
  9.         allowNull: false
  10.       },
  11.       userId: {
  12.         type: Sequelize.INTEGER,
  13.         references: {
  14.           model: {
  15.             tableName: 'users',
  16.             schema: 'schema'
  17.           }
  18.           key: 'id'
  19.         },
  20.         allowNull: false
  21.       },
  22.     });
  23.   },
  25.   down: (queryInterface, Sequelize) => {
  26.     return queryInterface.dropTable('Person');
  27.   }
  28. }

.sequelizerc 文件

这是一个特殊的配置文件. 它允许你指定通常作为参数传递给CLI的各种选项:

env: 在其中运行命令的环境 config: 配置文件的路径 options-path: 带有其他参数的 JSON 文件的路径 migrations-path: migrations 文件夹的路径 seeders-path: seeders 文件夹的路径 models-path: models 文件夹的路径 url: 要使用的数据库连接字符串. 替代使用 —config 文件 debug: 可用时显示各种调试信息

初始化项目

  1. # 创建数据库
  2. npx sequelize db:create
  3. # 创建表
  4. npx sequelize db:migrate
  5. # 创建默认值
  6. npx sequelize db:seed:all

数据回滚

  1. # 如果你想撤消所有的种子
  2. npx sequelize-cli db:seed:undo:all
  3. # 回退到初始状态
  4. npx sequelize db:migrate:undo:all

生成公钥：openssl genrsa -out rsa_private_key.pem 1024 生成私钥: openssl rsa -in rsa_private_key.pem -pubout -out rsa_public_key.pem

```

mongoose

egg-mongoose GitHub地址