Sequelize 使用

Sequelize github 查看更多

Sequelize 中文

什么是ORM？

简单的讲就是对SQL查询语句的封装，让我们可以用OOP的方式操作数据库，优雅的生成安全、可维护的SQL代码。直观上，是一种Model和SQL的映射关系

什么是Sequelize

Sequelize是一款基于Nodejs功能强大的异步ORM框架。
同时支持PostgreSQL, MySQL, SQLite and MSSQL多种数据库，很适合作为Nodejs后端数据库的存储接口，为快速开发Nodejs应用奠定扎实、安全的基础。

安装

npm install --save sequelize
npm install --save mysql
npm install --save mysql2

连接数据库

const Sequelize = require('sequelize');
/**
 * 配置数据库
 * 第一个参数 boblog    数据库名字
 * 第二个参数 root      数据库名字
 * 第三个参数 password  数据库密码
 */
const sequelize = new Sequelize('boblog', 'root', '', {
    host: 'localhost',
    dialect: 'mysql',
    operatorsAliases: false,
    dialectOptions: {
        charset: "utf8mb4",
        collate: "utf8mb4_unicode_ci",
        supportBigNumbers: true,
        bigNumberStrings: true
    },

    pool: {
        max: 5,
        min: 0,
        acquire: 30000,
        idle: 10000
    },
    timezone: '+08:00' //东八时区
});

//验证是否连接成功
sequelize.authenticate().then(() => {
        console.log('Success.');
}).catch(err => {
        console.error('Failed', err);
});

新建模型 schema

模型定义详细文档（验证器、自定义验证器等）

createdAt updatedAt 不用传 sequelize会自动添加
属性：
type
allowNull: false, 是否允许值为null
primaryKey: true, 是否为主键
autoIncrement: true 主键是否自增
field 'limits', 指定数据表字段名
unique: true 创建唯一约束
defaultValue: sequelize.NOW 设置时间默认值
defaultValue: 其他默认值
comment: '这是一个包含注释的列名'

//schema/role.js
const moment = require('moment');
module.exports = function (sequelize, DataTypes) {
    return sequelize.define('role', {
        id: {
            type: DataTypes.INTEGER.UNSIGNED,
            allowNull: false,
            primaryKey: true,
            autoIncrement: true
        },
        // 角色名字
        name: {
            type: DataTypes.STRING(100),
            field: 'name',
            allowNull: false
        },
        // 角色权限
        limits: {
            type: DataTypes.INTEGER.UNSIGNED,
            allowNull: false,
            field: 'limits',
            default: 0
        },
         // 这可以创建一个外键:
        bar_id: {
           type: Sequelize.INTEGER,
           references: {
              // 这是引用另一个模型
              model: Bar,
               // 这是引用模型的列名称
              key: 'id',
               // 这声明什么时候检查外键约束. 仅限PostgreSQL.
              deferrable: Sequelize.Deferrable.INITIALLY_IMMEDIATE
        }
        createdAt: {
            type: DataTypes.DATE,
            field: 'created_id',
            get() {
                return moment(this.getDataValue('createdAt')).format('YYYY-MM-DD');
            }
        },
        updatedAt: {
            type: DataTypes.DATE,
            field: 'updated_id',
            get() {
                return moment(this.getDataValue('updatedAt')).format('YYYY-MM-DD HH:mm:ss');
            }
        }
    }, {
        // 如果为 true 则表的名称和 model 相同，即 user
        // 为 false MySQL创建的表名称会是复数 users
        // 如果指定的表名称本就是复数形式则不变
        timestamps: false,  //去除createAt updateAt
       freezeTableName: true,  使用自定义表名

    })
}

新建model

//model/RoleModel.js
const db = require('../config/db');
const Sequelize = db.sequelize;
const Op = Sequelize.Op;
const Role = Sequelize.import('../schema/role');
Role.sync({force: false});

关联表查询

const Article = Sequelize.import('../schema/article');
const Category = Sequelize.import('../schema/category');
const User = Sequelize.import('../schema/user');
//设置表关联
Category.hasMany(Article); // 将会添加 category_id 到 ArticleModel 模型
User.hasMany(Article); // 将会添加 authorId 到 ArticleModel 模型
//设置关联外键
Article.belongsTo(Category, {foreignKey: 'categoryId'});
Article.belongsTo(User, {foreignKey: 'authorId'});

//使用
Article.findOne({
     where: {
           id,
           is_del: 0
    },
    include: [{
         model: Category,
         where: {categoryId: Sequelize.col('article.categoryId')}
     }, {
         model: User,
         where: {id: Sequelize.col('article.authorId')},
         attributes: ['id','nickname']
   }],
   attributes: {exclude: ['is_del']}
}).then(res=>{})

关联 association

不需要外键关联
hasMany 一对多
hasOne 一对已一
belongsTo 属于

return await Test.findOne({
   where:{id},
   include: [ { 
    //关连键(test_id)在TestTitles表上
     association:Test.hasMany(TestTitles,{foreignKey: 'test_id',as:'titles'}),
     include:[ {
           association:TestTitles.hasMany(TestOptions,{foreignKey: 't_id',as:'options'})
     } ],
   },]
 });

//关联键在UserTest上
await UserTest.findAndCountAll({
    where:{userId},
    include: [ {
         association:UserTest.belongsTo(Test,{foreignKey: 'testId'}),
    }]
})

操作符

查看代码

 const Op = Sequelize.Op

[Op.and]: {a: 5}           // 且 (a = 5)
[Op.or]: [{a: 5}, {a: 6}]  // (a = 5 或 a = 6)
[Op.gt]: 6,                // id > 6
[Op.gte]: 6,               // id >= 6
[Op.lt]: 10,               // id < 10
[Op.lte]: 10,              // id <= 10
[Op.ne]: 20,               // id != 20
[Op.eq]: 3,                // = 3
[Op.not]: true,            // 不是 TRUE
[Op.between]: [6, 10],     // 在 6 和 10 之间
[Op.notBetween]: [11, 15], // 不在 11 和 15 之间
[Op.in]: [1, 2],           // 在 [1, 2] 之中
[Op.notIn]: [1, 2],        // 不在 [1, 2] 之中
[Op.like]: '%hat',         // 包含 '%hat'
[Op.notLike]: '%hat'       // 不包含 '%hat'
[Op.iLike]: '%hat'         // 包含 '%hat' (不区分大小写)  (仅限 PG)
[Op.notILike]: '%hat'      // 不包含 '%hat'  (仅限 PG)
[Op.regexp]: '^[h|a|t]'    // 匹配正则表达式/~ '^[h|a|t]' (仅限 MySQL/PG)
[Op.notRegexp]: '^[h|a|t]' // 不匹配正则表达式/!~ '^[h|a|t]' (仅限 MySQL/PG)
[Op.iRegexp]: '^[h|a|t]'    // ~* '^[h|a|t]' (仅限 PG)
[Op.notIRegexp]: '^[h|a|t]' // !~* '^[h|a|t]' (仅限 PG)
[Op.like]: { [Op.any]: ['cat', 'hat']} // 包含任何数组['cat', 'hat'] - 同样适用于 iLike 和 notLike
[Op.overlap]: [1, 2]       // && [1, 2] (PG数组重叠运算符)
[Op.contains]: [1, 2]      // @> [1, 2] (PG数组包含运算符)
[Op.contained]: [1, 2]     // <@ [1, 2] (PG数组包含于运算符)
[Op.any]: [2,3]            // 任何数组[2, 3]::INTEGER (仅限PG)

[Op.col]: 'user.organization_id' // = 'user'.'organization_id', 使用数据库语言特定的列标识符, 本例使用 PG

支持原生sql语句

const db = require('../config/db');
const Sequelize = db.sequelize;
Sequelize.query('select * from user').then(res=>{
          console.log(res)
})
//其他查询同上

常用DataTypes

更多查看文档

Sequelize.STRING                      // VARCHAR(255)
Sequelize.STRING(1234)                // VARCHAR(1234)
Sequelize.STRING.BINARY               // VARCHAR BINARY
Sequelize.TEXT                        // TEXT
Sequelize.TEXT('tiny')                // TINYTEXT

Sequelize.INTEGER                     // INTEGER
Sequelize.BIGINT                      // BIGINT
Sequelize.BIGINT(11)                  // BIGINT(11)

Sequelize.FLOAT                       // FLOAT
Sequelize.FLOAT(11)                   // FLOAT(11)
Sequelize.FLOAT(11, 12)               // FLOAT(11,12)

Sequelize.REAL                        // REAL         仅限于PostgreSQL.
Sequelize.REAL(11)                    // REAL(11)     仅限于PostgreSQL.
Sequelize.REAL(11, 12)                // REAL(11,12)  仅限于PostgreSQL.

Sequelize.DOUBLE                      // DOUBLE
Sequelize.DOUBLE(11)                  // DOUBLE(11)
Sequelize.DOUBLE(11, 12)              // DOUBLE(11,12)

Sequelize.DECIMAL                     // DECIMAL
Sequelize.DECIMAL(10, 2)              // DECIMAL(10,2)

Sequelize.DATE                        // DATETIME 针对 mysql / sqlite, TIMESTAMP WITH TIME ZONE 针对 postgres
Sequelize.DATE(6)                     // DATETIME(6) 针对 mysql 5.6.4+. 小数秒支持多达6位精度
Sequelize.DATEONLY                    // DATE 不带时间.
Sequelize.BOOLEAN                     // TINYINT(1)

Sequelize.ENUM('value 1', 'value 2')  // 一个允许具有 “value 1” 和 “value 2” 的 ENUM
Sequelize.ARRAY(Sequelize.TEXT)       // 定义一个数组。 仅限于 PostgreSQL。
Sequelize.ARRAY(Sequelize.ENUM)       // 定义一个 ENUM 数组. 仅限于 PostgreSQL。

作者：zlb123456
链接：https://www.jianshu.com/p/4f7353cd5805
来源：简书