sequelize的Op对象常用方法标记

近期在使用sequelize 的Nodejs 的ORM，基于Promise的，支持 Postgres, MySQL, MariaDB, SQLite 以及 Microsoft SQL Server. 它具有强大的事务支持, 关联关系, 预读和延迟加载,读取复制等功能。

不过在使用过程中发现了Op模块，查询了一下，以下方法可以使用，标记一下。

  // 查找users表数据name
  const op = models.Sequelize.Op;
  let {age} = req.query;
  let user = await models.User.findAll({
    where: { 
      age: {
        [op.between]: [0, 24] // 查询年龄在0-24岁的
      }
    }
  })

除了between之外，还涉及：

    adjacent: 邻近的 [Op.adjacent]: [1, 2]
    
    all：所有 [Op.gt]: { [Op.all]: literal('SELECT 1') }
    
    and：并且 [Op.and]: {a: 5}
    
    any：任意 [Op.any]: [2,3]
    
    between：之间 [Op.between]: [10, 20]
    
    col：
    
    contained：
    
    contains：
    
    endsWith：以结束 [Op.endsWith]: 'm'
    
    eq：= 等于 [Op.eq]: 12
    
    gt：> 大于 [Op.gt]: 6
    
    gte：>= 大于等于 [Op.gte]: 6
    
    iLike：
    
    in：查询包含的状态 [Op.in]: [12, 25]
    
    iRegexp：
    
    is：是否，判断类 [Op.is]: null
    
    like：模糊匹配，包含 [Op.like]: '%m%'
    
    lt：< 小于 [Op.lt]: 23
    
    lte：<= 小于等于 [Op.lte]: 10
    
    ne：!= 不等于 [Op.ne]: 23
    
    noExtendLeft：
    
    noExtendRight：
    
    not：非查询 [Op.not]: null
    
    notBetween：不在xx和xx之间的 [Op.notBetween]: [11, 23]
    
    notILike：
    
    notIn：查询不包含的状态 [Op.notIn]: [12, 25]
    
    notIRegexp：
    
    notLike：模糊匹配，不包含 [Op.notLike]: '%m%'
    
    notRegexp：正则，不以开始 [Op.notRegexp]: '^[h|a|t]'
    
    or：或者 where:{ [Op.or]:[ {parent_id:id}, {id:id} ] }
    
    overlap：重叠部分 [Op.overlap]: [1, 2]
    
    placeholder：占位符
    
    regexp：正则，以开始 [Op.regexp]: '^[h|a|t]'
    
    startsWith：字符串，以*开始 [Op.startsWith]: 'j'
    
    strictLeft：
    
    strictRight：
    
    substring：模糊匹配 [Op.substring]: 'oh'
    
    values：

Demo示意如下：

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