sequelize_sequelize条件查询 - CSDN
精华内容
参与话题
  • 关于sequelize的准备工作这里不再赘述. 一、引入sequelize模块 var Sequelize = require('sequelize'); 二、连接数据库 var sequelize = new Sequelize( 'sample', // 数据库名 'root', // 用户名 ...
    关于sequelize的准备工作这里不再赘述.
    


    一、引入sequelize模块

    var Sequelize = require('sequelize');

    二、连接数据库

    var sequelize = new Sequelize(
        'sample', // 数据库名
        'root',   // 用户名
        'psw',   // 用户密码
        {
            'dialect': 'mysql',  // 数据库使用mysql
            'host': 'localhost', // 数据库服务器ip
            'port': 3306,        // 数据库服务器端口
            'define': {
                // 字段以下划线(_)来分割(默认是驼峰命名风格)
                'underscored': true
            }
        }
    );

    三、定义表

    var User = sequelize.define(
    
        'user',
    
        {
    
            userId: {
                field: 'user_id',
                primaryKey: true,
                type: Sequelize.BIGINT,
                allowNull: false
            },
            userName: {
                field: 'user_name',
                type: Sequelize.STRING,
                allowNull: false
            },
            userIcon: {
                field: 'user_icon',
                type: Sequelize.STRING,
                allowNull: true
            },
            title: {
                field: 'title',
                type: Sequelize.STRING,
                allowNull: true
            },
            gender: {
                field: 'gender',
                type: Sequelize.ENUM('MALE','FEMALE'),
                allowNull: true
            },
            birth: {
                field: 'birth',
                type: Sequelize.STRING,
                allowNull: true
            },
            mail: {
                field: 'mail',
                type: Sequelize.STRING,
                allowNull: true
            },
            tel: {
                field: 'tel',
                type: Sequelize.STRING,
                allowNull: true
            },
            mobile: {
                field: 'mobile',
                type: Sequelize.STRING,
                allowNull: true
            },
            updateTime: {
                field: 'update_time',
                type: Sequelize.STRING,
                allowNull: true
            }
        },
        {
            tableName: 'user',
            timestamps: false,
            freezeTableName: true
        }
    
    
    );


    四、往表里添加数据

    User.create({
        userId: 23,
        userName: '老杨',
        updateTime: '2016-01-22 18:37:22'
    });


    五、修改表内数据


    var pram={'userName':'晓博'};
    
    user.update(
    
        pram,{
            
                'where':{'userId':{eq:23}}
    }
    );//将userId等于23的userName改为'晓博'
    六、删除表内数据

    user.destroy({'where':{'id':{eq:23}}});//将表内userId等于23的元组删除




    展开全文
  • Sequelize 入门

    2020-04-07 23:09:06
    Sequelize Sequelize.js 提供对 MySQL,MariaDB,SQLite 和 PostgreSQL 数据库的简单访问,通过映射数据库条目到对象,或者对象到数据库条目。简而言之,就是 ORM(Object-Relational-Mapper)。Sequelize.js 完全...

    三月份事情比较多,学得乱七八糟,差点被新单位入Java坑

    前端不香吗? node.js不香吗

    后台数据库还是入mysql的坑吧

    Sequelize

    Sequelize.js 提供对 MySQL,MariaDB,SQLite 和 PostgreSQL 数据库的简单访问,通过映射数据库条目到对象,或者对象到数据库条目。简而言之,就是 ORM(Object-Relational-Mapper)。Sequelize.js 完全是使用 JavaScript 编写,适用于 Node.js 的环境。

    sequlize 中文官方文档:链接地址

    本文已操作mysql为例

    安装

    npm install --save sequelize
    npm install --save mysql2 // 安装驱动
    

    建立连接

    db.js

    const Sequelize = require('sequelize')
    
    const sequelize = new Sequelize(dbName, user, password, {
      dialect: 'mysql',
      host:"",
      port:"",
      logging: false,  // 是否在控制台打印出原生sql语句
      timezone: '+08:00', // 时区
      pool: {  // 池
        max: 5,
        min: 0,
        acquire: 30000,
        idle: 10000,
      },
      define: {
        // create_time && update_time
        timestamps: true, // 是否时间戳
        createdAt: 'created_at',
        updatedAt: 'updated_at',
        deletedAt: 'deleted_at',
        // 把驼峰命名转换为下划线
        underscored: true,
        scopes: {} // 作用域规则 可以包括与常规查找器 where, include, limit 等所有相同的属性
      }
    })
    // 创建模型
    sequelize.sync({force: false}) // 是否删除再重新创建
    module.exports = {
      sequelize
    }
    

    创建Model

    const moment = require('moment'); // 格式化时间库
    
    const {sequelize} = require('./db'); // 即是上文连接数据库后返回的模型实例
    const {Sequelize, Model} = require('sequelize')
    
    // 定义文章分裂模型
    class CategoryModel extends Model {
    	// 可在此写一些实例方法或者静态方法
    }
    
    // 初始分类模型
    CategoryModel.init({
      id: {
        type: Sequelize.INTEGER, // 类型
        primaryKey: true, // 主键
        autoIncrement: true  // 自增长
      },
      name: {
        type: Sequelize.STRING,
        allowNull: false, // 允许为空
        comment: '分类名称'
      },
      keyword: {
        type: Sequelize.STRING,
        allowNull: false,
        comment: '分类关键字'
      },
      parent_id: {
        type: Sequelize.INTEGER,
        allowNull: true,
        defaultValue: 0,
        comment: '分类父级ID,默认为0'
      },
      created_at: {
        type: Sequelize.DATE,
        allowNull: false,
        get() {
          return moment(this.getDataValue('created_at')).format('YYYY-MM-DD');
        }
      }
    }, {
      sequelize,
      modelName: 'category',
      tableName: 'category'
    })
    
    module.exports = {
      Category
    }
    

    增删改查

    
    // 增
    (async () => {
      const now = Date.now()
      const user = await CategoryModel.create({
        name: '',
        parent_id: 'root',
        keyword: '',
      })
      console.log('创建:' + JSON.stringify(user))
    })();
    
    
    //查
    (async () => {
      // 查找所有
      const allCate = await CategoryModel.findAll()
    
      // 按id查找
      const oneCate = await CategoryModel.findByPk(id)
    
      // 按条件查询
      const someCate = await CategoryModel.findAll({
        where: {
          // 模糊查询
          name: {
            $like: '小%',
          },
          // 精确查询
          keyword: 'xxx',
        }
      })
    
      // 分页查询
      const size = 10 // 每页10条数据
      const page = 1 // 页数
      const pageUser = await CategoryModel.findAndCountAll({
        where: {
          name: {
            $like: '%小',
          },
        },
        limit: size,
        offset: size * (page - 1),
      })
    })();
    
    // 改
    (async () => {
    // 方法一
    await CategoryModel.upsert(data)  // data 里面如果带有 id 则更新,不带则新建
    
    // 方法二
    const cate= await CategoryModel.findByPk(id)
    cate.update(data)
    })()
    
    
    // 删
    (async () => {
    // 方法一
    // 删除所有名字带’小‘的用户
    await CategoryModel.destroy({
      where: {
        name: 'xx',
      },
    })
    
    // 方法二
    const user = await UserModel.findByPk(id)
    user.destroy()
    })()
    

    op

    const { Op }= Sequelize
    
    [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
    

    常用内置变量

    $and: {a: 5}           // AND (a = 5)
    $or: [{a: 5}, {a: 6}]  // (a = 5 OR a = 6)
    $gt: 6,                // > 6
    $gte: 6,               // >= 6
    $lt: 10,               // < 10
    $lte: 10,              // <= 10
    $ne: 20,               // != 20
    $not: true,            // IS NOT TRUE
    $between: [6, 10],     // BETWEEN 6 AND 10
    $notBetween: [11, 15], // NOT BETWEEN 11 AND 15
    $in: [1, 2],           // IN [1, 2]
    $notIn: [1, 2],        // NOT IN [1, 2]
    $like: '%hat',         // LIKE '%hat'
    $notLike: '%hat'       // NOT LIKE '%hat'
    $iLike: '%hat'         // ILIKE '%hat' (case insensitive) (PG only)
    $notILike: '%hat'      // NOT ILIKE '%hat'  (PG only)
    $like: { $any: ['cat', 'hat']}
                           // LIKE ANY ARRAY['cat', 'hat'] - also works for iLike and notLike
    $overlap: [1, 2]       // && [1, 2] (PG array overlap operator)
    $contains: [1, 2]      // @> [1, 2] (PG array contains operator)
    $contained: [1, 2]     // <@ [1, 2] (PG array contained by operator)
    $any: [2,3]            // ANY ARRAY[2, 3]::INTEGER (PG only)
    
    $col: 'user.organization_id' // = "user"."organization_id", with dialect specific column identifiers, PG in this example
    
    展开全文
  • Nodejs ORM框架Sequelize快速入门

    万次阅读 2017-08-28 11:49:50
    Nodejs ORM框架Sequelize快速入门

    Nodejs ORM框架Sequelize快速入门


    什么是ORM?


    简单的讲就是对SQL查询语句的封装,让我们可以用OOP的方式操作数据库,优雅的生成安全、可维护的SQL代码。直观上,是一种Model和SQL的映射关系。
    const User = sequelize.define('user', {
        id: {
            type: Sequelize.INTEGER,
            allowNull: false,
            autoIncrement: true,
            primaryKey: true
        },
        email: {
            type: Sequelize.STRING,
            allowNull: false,
            validate: {
                isEmail: true
            },
            unique: true
        }
    })
    CREATE TABLE IF NOT EXISTS `users` (
      `id` INTEGER PRIMARY KEY AUTOINCREMENT,
      `email` VARCHAR(255) NOT NULL UNIQUE
      `createdAt` DATETIME NOT NULL,
      `updatedAt` DATETIME NOT NULL,
      UNIQUE (email)
    );

    那么什么是Sequelize?


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

    既然Nodejs的强项在于异步,没有理由不找一个强大的支持异步的数据库框架,与之配合,双剑合并~
    //引入框架
    var Sequelize = require('sequelize');
    //初始化链接(支持连接池)
    var sequelize = new Sequelize('database', 'username', 'password',  {
      host: 'localhost',
      dialect: 'mysql'|'sqlite'|'postgres'|'mssql',
      pool: {
        max: 5,
        min: 0,
        idle: 10000
      },
      // SQLite only
      storage: 'path/to/database.sqlite'
    });
    //定义数据模型
    var User = sequelize.define('user', {
      username: Sequelize.STRING,
      birthday: Sequelize.DATE
    });
    //初始化数据
    sequelize.sync().then(function() {
      return User.create({
        username: 'janedoe',
        birthday: new Date(1980, 6, 20)
      });
    }).then(function(jane) {
      //获取数据
      console.log(jane.get({
        plain: true
      }));
    }).catch(function (err) {
      //异常捕获
      console.log('Unable to connect to the database:', err);
    });

    Sequelize有哪些特色?


    强大的模型定义,支持虚拟类型。Javascript虽然被很多人诟病杂乱无章法,但是函数即对象这个特色,可以说是我的最爱,非常灵活强大。
    var Foo = sequelize.define('foo', {
      firstname: Sequelize.STRING,
      lastname: Sequelize.STRING
    }, {
      getterMethods   : {
        fullName       : function()  { return this.firstname + ' ' + this.lastname }
      },
      setterMethods   : {
        fullName       : function(value) {
            var names = value.split(' ');
            this.setDataValue('firstname', names.slice(0, -1).join(' '));
            this.setDataValue('lastname', names.slice(-1).join(' '));
        },
      }
    });

    支持完善的数据验证,减轻前后端的验证压力。
    var ValidateMe = sequelize.define('foo', {
      foo: {
        type: Sequelize.STRING,
        validate: {
          is: ["^[a-z]+$",'i'],     // 全匹配字母
          is: /^[a-z]+$/i,          // 全匹配字母,用规则表达式写法
          not: ["[a-z]",'i'],       // 不能包含字母
          isEmail: true,            // 检查邮件格式
          isUrl: true,              // 是否是合法网址
          isIP: true,               // 是否是合法IP地址
          isIPv4: true,             // 是否是合法IPv4地址
          isIPv6: true,             // 是否是合法IPv6地址
          isAlpha: true,            // 是否是字母
          isAlphanumeric: true,     // 是否是数字和字母
          isNumeric: true,          // 只允许数字
          isInt: true,              // 只允许整数
          isFloat: true,            // 是否是浮点数
          isDecimal: true,          // 是否是十进制书
          isLowercase: true,        // 是否是小写
          isUppercase: true,        // 是否大写
          notNull: true,            // 不允许为null
          isNull: true,             // 是否是null
          notEmpty: true,           // 不允许为空
          equals: 'specific value', // 等于某些值
          contains: 'foo',          // 包含某些字符
          notIn: [['foo', 'bar']],  // 不在列表中
          isIn: [['foo', 'bar']],   // 在列表中
          notContains: 'bar',       // 不包含
          len: [2,10],              // 长度范围
          isUUID: 4,                // 是否是合法 uuids
          isDate: true,             // 是否是有效日期
          isAfter: "2011-11-05",    // 是否晚于某个日期
          isBefore: "2011-11-05",   // 是否早于某个日期
          max: 23,                  // 最大值
          min: 23,                  // 最小值
          isArray: true,            // 是否是数组
          isCreditCard: true,       // 是否是有效信用卡号
          // 自定义规则
          isEven: function(value) {
            if(parseInt(value) % 2 != 0) {
              throw new Error('请输入偶数!')
            }
          }
        }
      }
    });

    Sequelize的查询非常全面和灵活
    Project.findAll({
      //复杂过滤,可嵌套
      where: {
        id: {
          $and: {a: 5}           // AND (a = 5)
          $or: [{a: 5}, {a: 6}]  // (a = 5 OR a = 6)
          $gt: 6,                // id > 6
          $gte: 6,               // id >= 6
          $lt: 10,               // id < 10
          $lte: 10,              // id <= 10
          $ne: 20,               // id != 20
          $between: [6, 10],     // BETWEEN 6 AND 10
          $notBetween: [11, 15], // NOT BETWEEN 11 AND 15
          $in: [1, 2],           // IN [1, 2]
          $notIn: [1, 2],        // NOT IN [1, 2]
          $like: '%hat',         // LIKE '%hat'
          $notLike: '%hat'       // NOT LIKE '%hat'
          $iLike: '%hat'         // ILIKE '%hat' (case insensitive)  (PG only)
          $notILike: '%hat'      // NOT ILIKE '%hat'  (PG only)
          $overlap: [1, 2]       // && [1, 2] (PG array overlap operator)
          $contains: [1, 2]      // @> [1, 2] (PG array contains operator)
          $contained: [1, 2]     // <@ [1, 2] (PG array contained by operator)
          $any: [2,3]            // ANY ARRAY[2, 3]::INTEGER (PG only)
        },
        status: {
          $not: false,           // status NOT FALSE
        }
      }
    })
    Project.all()
    Project.findById
    Project.findByOne
    Project.findOrCreate
    Project.findAndCountAll
    Project.count()
    Project.max()
    //CRUD
    Project.create()
    Project.save()
    Project.update()
    Project.destroy()
    //批量
    User.bulkCreate([])
    //排序
    something.findOne({
      order: [
        'name',
        // 返回 `name`
        'username DESC',
        // 返回 `username DESC`
        ['username', 'DESC'],
        // 返回 `username` DESC
        sequelize.fn('max', sequelize.col('age')),
        // 返回 max(`age`)
        [sequelize.fn('max', sequelize.col('age')), 'DESC'],
        // 返回 max(`age`) DESC
        [sequelize.fn('otherfunction', sequelize.col('col1'), 12, 'lalala'), 'DESC'],
        // 返回 otherfunction(`col1`, 12, 'lalala') DESC
        [sequelize.fn('otherfunction', sequelize.fn('awesomefunction', sequelize.col('col'))), 'DESC']
        // 返回 otherfunction(awesomefunction(`col`)) DESC, 有可能是无限循环
        [{ raw: 'otherfunction(awesomefunction(`col`))' }, 'DESC']
        // 也可以这样写
      ]
    })
    // 分页查询
    Project.findAll({ limit: 10 })
    Project.findAll({ offset: 8 })
    Project.findAll({ offset: 5, limit: 5 })
    //关联查询 include 支持嵌套,这可能是ORM里面最难的部分。

    var User = sequelize.define('user', { name: Sequelize.STRING })
      , Task = sequelize.define('task', { name: Sequelize.STRING })
      , Tool = sequelize.define('tool', { name: Sequelize.STRING })
    Task.belongsTo(User) // 增加外键属性 UserId 到 Task
    User.hasMany(Task) // 给 Task 增加外键属性 userId
    User.hasMany(Tool, { as: 'Instruments' }) // 给 Task 增加自定义外键属性 InstrumentsId
    Task.findAll({ include: [ User ] })
    User.findAll({ include: [{
        model: Tool,
        as: 'Instruments',
        where: { name: { $like: '%ooth%' } }
    }] })
    User.findAll({ include: ['Instruments'] })
    var User = this.sequelize.define('user', {/* attributes */}, {underscored: true})
      , Company  = this.sequelize.define('company', {
        uuid: {
          type: Sequelize.UUID,
          primaryKey: true
        }
      });
    User.belongsTo(Company); // 增加 company_uuid 外键属性到 user
    User.belongsTo(UserRole, {as: 'role'});
    // 自定义外键属性 roleId 到 user 而不是 userRoleId
    User.belongsTo(Company, {foreignKey: 'fk_companyname', targetKey: 'name'}); // 增加自定义外键属性 fk_companyname 到 User
    Person.hasOne(Person, {as: 'Father', foreignKey: 'DadId'})
    // Person 增加外键属性 DadId
    Coach.hasOne(Team)  // `coachId` 作为 Team 的外键属性
    Project.hasMany(User, {as: 'Workers'})
    // 给 User 增加外键属性 projectId / project_id
    Project.belongsToMany(User, {through: 'UserProject'});
    User.belongsToMany(Project, {through: 'UserProject'});
    // 创建新的模型: UserProject 包含外键属性:projectId 和 userId

    Sequelize还有完善的迁移同步数据方案,migrate so easy。

    //$ sequelize db:migrate //用命令直接生成模版脚本,接下来的还是写js
    module.exports = {
      up: function(queryInterface, Sequelize) {
        // 需要修改数据库的操作
      },
      down: function(queryInterface, Sequelize) {
        // 取消修改的操作
      }
    }

    转自: http://hopperclouds.github.io/2016/09/12/Nodejs-ORM%E6%A1%86%E6%9E%B6Sequelizejs%E5%BF%AB%E9%80%9F%E5%85%A5%E9%97%A8/

    --- end ---

    展开全文
  • Sequelize基本用法

    2019-09-17 11:01:31
    $ npm install --save sequelize # 还需要安装以下之一: $ npm install --save pg pg-hstore // postgreSql $ npm install --save mysql // mysql 或 mariadb $ npm install --save sqlite3 $ npm install --save ...

    安装

    $ npm install --save sequelize
    # 还需要安装以下之一:
    $ npm install --save pg pg-hstore  // postgreSql
    $ npm install --save mysql // mysql 或 mariadb
    $ npm install --save sqlite3  
    $ npm install --save tedious // MSSQL
    

    建立连接

    const Sequelize = require('sequelize')
    const sequelize = new Sequelize(db.database, db.user, db.password, { //表名 用户名 密码
        host: db.host, //地址
        port: db.port, //端口
        dialect: 'mysql', //数据库类型:'mysql'|'mariadb'|'sqlite'|'postgres'|'mssql'
        pool: { // 连接池配置
            max: 5,
            min: 0,
            acquire: 30000,
            idle: 10000,
        },
        timezone: '+08:00' //时区转换
    })
    

    定义模型

    const Sequelize = require('sequelize')
    const moment=require('moment');
    moment.locale('zh-cn');
    
    User: sequelize.define('user', {
    	id: {
    		type: Sequelize.STRING(255),
    		primaryKey: true, //主键
    	},
    	name: Sequelize.STRING,
    	role: Sequelize.INTEGER(11),
    	open_id: Sequelize.STRING,
    	describe: Sequelize.STRING,
    	status: Sequelize.INTEGER(11),
    	lv: Sequelize.INTEGER(11),
    	token: Sequelize.STRING,
    	create_time:{
    	type: Sequelize.DATE,
    		get() {return moment(this.getDataValue('create_time')).format('YYYY-MM-DD HH:mm:ss');}
    	},
    	update_time:{
    		type: Sequelize.DATE,
    		get() {return moment(this.getDataValue('update_time')).format('YYYY-MM-DD HH:mm:ss');}
    	}
    }, {
    	freezeTableName: true,
    	timestamps: false
    })
    

    sql、orm对应关系

    sql orm
    select findAll,findOne,findById,findOrCreate,findAndCountAll
    update update
    insert create
    delete destroy

    查询

    查询单条数据

    User.findOne({
    	attributes: ['id', 'name', 'role', 'open_id', 'describe'],
    	where: {
    		id: id
    	}
    }).then(result => {
    	console.log(result)
    }).catch(err => {
    	console.log(err)
    });
    

    查询多条

    findAll(opts) 或者 all(opts)

    User.findAll()
    

    分页查询

    findAndCount(opts) 或者 findAndCountAll

    User.findAndCount({
        limit:10,//每页10条
        offset:0*10,//第x页*每页个数
        where:{}
    });
    

    通过id查询

    findById(id,opts)

    User.findById(1);
    

    查询,不存在就新建一个

    findOrCreate(opts)或者findCreateFind

    User.findOrCreate({
    	where: {
    		open_id: req.body.open_id
    	},
    	defaults: {
    		id: id,
    		name: req.body.name,
    		open_id: req.body.open_id,
    		token: token,
    		create_time: Date.now()
    	}
    }).then(result => {
    	//返回值为数组,[json,created] 第一位是查询或创建的数据,第二位标识是否新建
    })
    

    分组查询

    分组查询通常要与聚合函数一起使用,聚合函数包括:

    聚合函数 功能
    COUNT() 用于统计记录条数
    SUM() 用于计算字段的值的总和
    AVG() 用于计算字段的值的平均值
    MAX 用于查找查询字段的最大值
    MIX 用于查找查询字段的最小值
    //求表中like字段值的和
    orm.Article.findAll({
    	attributes: [[Sequelize.fn('SUM', Sequelize.col('like')), 'likes']],
    }).then(result=>{
    	result[0].get('likes')
    })
    

    更新

    User.update({
    	token: 'token'
    }, {
    	where: {
    		id: l
    	}
    }).then(result => {
    	console.log(result)
    }).catch(err => {
    	console.log(err)
    });
    

    新增

    User.create({
    	id: id,
    	name: req.body.name,
    	open_id: req.body.open_id,
    	create_time: Date.now()
    }).then(result => {
    	console.log(result)
    	}).catch(err => {
    	console.log(err)
    });
    

    删除

    User.destroy({
    	where: {
    		id: 1
    	}
    }).then(result => {
    	console.log(result)
    }).catch(err => {
    	console.log(err)
    });
    

    关联查询

    一对一

    sequelize 提供了两种一对一关系关联方法 belongsTo 和 hasOne

    User.belongsTo(Article, { foreignKey: 'id', as: 'article',targetKey:'user_id'})
    User.hasOne(Article, { foreignKey: 'user_id', as: 'article'})
    

    第一个参数为一个Model,第二个为options配置。
    foreignKey:指定外键
    as:指定别名
    targetKey:目标键,是源模型上的外键列指向的目标模型上的列,默认情况下是目标模型的主键
    两种方法都是把userInfo表关联到User表,区别是暴露外键的表不同:

    • belongsTo暴露出的是User表的‘id’字段作为外键去查询UserInfo表
    • hasOne方法暴露的是Article表的‘user_id’作为外键查询User表

    使用

    User.findeOne({
    	where: {},
    	include: {
    		model: Article,
    		as: 'article'
    		where: {},
    		required: false //仅对include的结果过滤
    	}
    })
    

    belongsTo 生成的sql

    SELECT `user`.`id`, `user`.`name`, `article`.`id` AS `article.id`, `article`.`title` AS `article.title`, `article`.`user_id` AS `article.user_id` FROM `user` AS `user` LEFT OUTER JOIN `article` AS `article` ON `user`.`id` = `article`.`user_id` WHERE `user`.`id` = '1';
    

    hasOne 生成的sql

    SELECT `user`.`id`, `user`.`name`,`article`.`id` AS `article.id`, `article`.`title` AS `article.title`, `article`.`user_id` AS `article.user_id` FROM `user` AS `user` LEFT OUTER JOIN `article` AS `article` ON `user`.`id` = `article`.`user_id` WHERE `user`.`id` = '1';
    

    belongsTo 使用User的外键作为条件去查询Article的主键
    hasOne使用Article的外键作为条件去查询User的主键

    一对多

    hasMany

    多对多

    belongToMany

    常用符号运算符

    Operators 解释
    [Op.and]: {a: 5} AND (a = 5)
    [Op.or]: [{a: 5}, {a: 6}] (a = 5 OR a = 6)
    [Op.gt]: 6, > 6
    [Op.gte]: 6, >= 6
    [Op.lt]: 10, < 10
    [Op.lte]: 10, <= 10
    [Op.ne]: 20, != 20
    [Op.eq]: 3, = 3
    [Op.not]: true, IS NOT TRUE
    [Op.between]: [6, 10], BETWEEN 6 AND 10
    [Op.notBetween]: [11, 15], NOT BETWEEN 11 AND 15
    [Op.in]: [1, 2], IN [1, 2]
    [Op.notIn]: [1, 2], NOT IN [1, 2]
    [Op.like]: ‘%hat’, LIKE ‘%hat’
    [Op.notLike]: ‘%hat’ NOT LIKE ‘%hat’
    [Op.iLike]: ‘%hat’ ILIKE ‘%hat’ (case insensitive) (PG only)
    [Op.notILike]: ‘%hat’ NOT ILIKE ‘%hat’ (PG only)
    [Op.startsWith]: ‘hat’ LIKE ‘hat%’
    [Op.endsWith]: ‘hat’ LIKE ‘%hat’
    [Op.substring]: ‘hat’ LIKE ‘%hat%’
    [Op.regexp]: '^[h a
    [Op.notRegexp]: '^[h a
    [Op.iRegexp]: '^[h a
    [Op.notIRegexp]: '^[h a
    [Op.like]: { [Op.any]: [‘cat’, ‘hat’]} LIKE ANY ARRAY[‘cat’, ‘hat’] - also works for iLike and notLike
    [Op.overlap]: [1, 2] && [1, 2] (PG array overlap operator)
    [Op.contains]: [1, 2] @> [1, 2] (PG array contains operator)
    [Op.contained]: [1, 2] <@ [1, 2] (PG array contained by operator)
    [Op.any]: [2,3] ANY ARRAY[2, 3]::INTEGER (PG only)
    [Op.col]: ‘user.organization_id’ = “user”.“organization_id”, with dialect specific column identifiers, PG in this example
    const Op = Sequelize.Op;
    //查询age < 18 或者小于5的数据
    User.findAll({
    	where: {
    		age:{
    			[Op.or]: {
    				[Op.lt]: 18,
    				[Op.eq]: 5
        		}
    		}
    	}
    }).then(result => {
    	console.log(result)
    }).catch(err => {
    	console.log(err)
    });
    

    永久链接: https://blog.qianxiaoduan.com/archives/776

    展开全文
  • Sequelize 中文API文档

    万次阅读 2017-08-07 20:31:46
    Sequelize 中文API文档-1. 快速入门、Sequelize类  2016年05月20日 35766 声明 Sequelize类是引用sequlize模块后获取一个顶级对象,我们通过它来创建sequlize实例,也可以通过该对象来获取模内其它对象...
  • sequelize(一)

    千次阅读 2016-07-20 19:22:42
    Sequelize.js 提供对 MySQL,MariaDB,SQLite 和 PostgreSQL 数据库的简单访问,通过映射数据库条目到对象,或者对象到数据库条目。是一个实用 ORM(Object-Relational-Mapper),适用于 Node.js 的环境。 1、node...
  • sequelize使用坑

    2019-10-07 17:27:05
    报错:hasOne Cannot add foreign key constraint 使用多表查询的时候,必须在建表后再使用 Student.sync(); // 先同步表 Student.hasMany(Info, {foreignKey: 'studentId'}); // 同步表以后就可以使用了 ...
  • Sequelize 中文文档整理(v5版本)

    千次阅读 2019-11-06 19:40:26
    前些年,本站整理过Sequelize相关中文文档,其时,Sequelize的版本为v3.*。现在Sequelize版本已更新到v5.19.6(本文发布之日),Sequelize的功能和API已有较大规模的更新,所以基于v5.*再进行一次梳理,以了解新功能及...
  • sequelize V5 升级记录

    2019-06-19 00:07:09
    最近把项目中的 sequelize 由 4.38.0 升级到了 5.8.7,以下是升级记录 本文地址: shanyue.tech/post/sequel… 01 删包 从 package.json 中删掉 sequelize 以及 @types/sequelize 02 过文档 大致过一遍官方升级文档 ...
  • sequelize 一对多 多对多

    千次阅读 2019-08-02 11:10:44
    /* * @Description: * @Author: 熊成强 * @Date: 2019-07-29 11:47:34 * @LastEditTime: 2019-08-02 11:03:06 * @LastEditors: 熊成强 */ var express = require('express'); var forToken = require('../...
  • Sequelize类是引用sequlize模块后获取一个顶级对象,我们通过它来创建sequlize实例,也可以通过该对象来获取模内其它对象的引用,如:Utils工具类、Transaction事务类等。创建实例后,可以通过实例来创建或定义Model...
  • 本文是对Sequelize 中文API文档系列文章的综合索引,及对sequelize模块和其内置对象的一些介绍,旨在帮助人们更好了解和使用Sequelize。文档索引官方文档对照sequelize模块介绍3.1 顶级对象Sequelize3.2 Model对象...
  • Sequelize

    2019-11-20 10:39:44
    Sequelize类是引用sequlize模块后获取一个顶级对象,我们通过它来创建sequlize实例,也可以通过该对象来获取模内其它对象的引用,如:Utils工具类、Transaction事务类等。创建实例后,可以通过实例来创建或定义Model...
  • 详解sequelize-cli管理数据库

    万次阅读 多人点赞 2020-06-05 13:47:09
    Sequelize迁移来帮助我们跟踪数据库的更改,并在各个不同时期的数据库状态之间进行切换
  • sequelize笔记

    千次阅读 2019-07-28 23:28:38
    npm install --save sequelize # 选择对应的安装: $ npm install --save pg pg-hstore # Postgres $ npm install --save mysql2 $ npm install --save mariadb $ npm install --save sqlite3 $ npm install --save ...
  • sequelize参考

    2018-12-26 09:48:25
    快速入门、SequelizeSequelize类是引用sequlize模块后获取一个顶级对象,我们通过它来创建sequlize实例,也可以通过该对象来获取模内其它对象的引用,如:Utils工具类、Transaction事务类等。创建实例后,可以...
  • 使用Sequelize连接数据库

    千次阅读 2018-08-09 11:04:57
    Sequelize.js是一款针对nodejs的ORM框架。 使用nodejs连接过数据库的人肯定对数据库不陌生了。如果是直接链接,需要自己建立并管理连接,还需要手动编写sql语句。简单的项目到是无所谓,可是一旦项目设计的东西比较...
  • Sequelize.js 入门

    千次阅读 2018-10-15 18:00:33
    学习sequelize.js 官方文档: http://docs.sequelizejs.com/manual/installation/getting-started.html 本文档对应的github路径: https://github.com/alex-my/javascript-learn/tree/master/sequelize 本文需要一点点...
  • 文章目录基本配置sequelize安装查看有哪些命令初始化配置数据库基本使用创建数据库创建模型和迁移文件数据类型迁移文件字段属性添加索引timestamp设置 基本配置 sequelize安装 yarn add sequelize yarn add ...
  • sequelize 查询

    2020-04-05 12:41:58
    Sequelize 中有两种查询:使用 Model(模型)中的方法查询和使用 sequelize.query() 进行基于 SQL 语句的原始查询。 下面是事先创建好的数据: mysql> select * from users; +----+----------+------+------+----...
1 2 3 4 5 ... 20
收藏数 3,691
精华内容 1,476
关键字:

sequelize