Sequelize 中文API文档－1. 快速入门、Sequelize类

Sequelize类是引用sequlize模块后获取一个顶级对象，我们通过它来创建sequlize实例，也可以通过该对象来获取模内其它对象的引用，如：Utils工具类、Transaction事务类等。创建实例后，可以通过实例来创建或定义Model（模型）、执行查询、同步数据库结构等操作。

1. 快速入门
   • 1.1 安装
   • 1.2 建立连接
   • 1.3 model定义
   • 1.4 Promise
2. Sequelize类
   • 2.1 new Sequelize() - 实例化
   • 2.2 new Sequelize() - 通过URI实例化
   • 2.3 sequelize.models - 实例中已定义的模型
   • 2.4 sequelize.define() - 模型定义
   • 2.5 Sequelize - 顶级对象
   • 2.6 Utils - 工具类
   • 2.7 Promise - Promise对象
   • 2.8 QueryTypes - 查询类型枚举
   • 2.9 Validator - validator.js对象
   • 2.10 Transaction - 事务对象
   • 2.11 Deferrable - 延时对象
   • 2.12 Instance - 实例对象
   • 2.13 Association - 联合关系对象
   • 2.14 Error - 错误对象
   • 2.15 ValidationError - 验证失败错误对象
   • 2.16 DatabaseError - 数据库错误对象
   • 2.17 TimeoutError - 查询超时错误对象
   • 2.18 UniqueConstraintError - 唯一性错误对象
   • 2.19 ExclusionConstraintError - 排出约束错误对象
   • 2.20 ForeignKeyConstraintError - 外键约束错误对象
   • 2.21 ConnectionError - 连接错误对象
   • 2.22 ConnectionRefusedError - 连接拒绝错误对象
   • 2.23 AccessDeniedError - 无访问权限错误对象
   • 2.24 HostNotFoundError - 主机未找到错误对象
   • 2.25 InvalidConnectionError - 无效链接错误对象
   • 2.26 ConnectionTimedOutError - 链接超时错误对象
   • 2.27 InstanceError - 实例错误对象
   • 2.28 sequelize.getDialect() - 返回数据库类型
   • 2.29 sequelize.getQueryInterface() - 返回QueryInterface实例
   • 2.30 sequelize.define() - 模型定义
   • 2.31 sequelize.model() - 获取模型
   • 2.32 sequelize.isDefined() - 检查模型是否定义
   • 2.33 sequelize.import() - 模型导入
   • 2.34 sequelize.query() - 执行查询
   • 2.35 sequelize.set() - 设置变量
   • 2.36 sequelize.escape() - 编码
   • 2.37 sequelize.createSchema() - 创建数据库 schema
   • 2.38 sequelize.showAllSchemas() - 查询已定义的schema
   • 2.39 sequelize.dropSchema() - 删除定义的schema
   • 2.40 sequelize.dropAllSchemas() - 删除所有schema
   • 2.41 sequelize.sync() - 同步模型到数据库
   • 2.42 sequelize.truncate() - 截断已定义的表
   • 2.43 sequelize.drop() - 删除表
   • 2.44 sequelize.authenticate() - 验证连接
   • 2.45 sequelize.fn() - 函数调用
   • 2.46 sequelize.col() - 列对象
   • 2.47 sequelize.cast() - cast函数
   • 2.48 sequelize.literal() - 字面量对象
   • 2.49 sequelize.and() - AND查询
   • 2.50 sequelize.or() - OR查询
   • 2.51 sequelize.json() - json嵌套对象
   • 2.52 sequelize.where() - 指定WHERE条件
   • 2.53 sequelize.transaction() - 启动事务

1. 快速入门

1.1 安装

Sequelize可以通过npm命令获取，除安装sequelize模块外还要安装所使用数据的驱动模块：

$ 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

1.2 建立连接

Sequelize会在初始化时设置一个连接池，这样你应该为每个数据库创建一个实例：

var sequelize = new Sequelize('database', 'username', 'password', {
  host: 'localhost',
  dialect: 'mysql'|'mariadb'|'sqlite'|'postgres'|'mssql',

  pool: {
    max: 5,
    min: 0,
    idle: 10000
  },

  // 仅 SQLite 适用
  storage: 'path/to/database.sqlite'
});

// 或者可以简单的使用一个连接 uri
var sequelize = new Sequelize('postgres://user:pass@example.com:5432/dbname');

1.3 model定义

model定义格式为sequelize.define('name', {attributes}, {options})：

var User = sequelize.define('user', {
  firstName: {
    type: Sequelize.STRING,
    field: 'first_name' // Will result in an attribute that is firstName when user facing but first_name in the database
  },
  lastName: {
    type: Sequelize.STRING
  }
}, {
  freezeTableName: true // Model 对应的表名将与model名相同
});

User.sync({force: true}).then(function () {
  // 已创建数据表
  return User.create({
    firstName: 'John',
    lastName: 'Hancock'
  });
});

1.4 Promise

Sequelize基于Promise实现异步流程控制，但其使用的并不是ECMAScript 6中规定的标准Promise对象，而是使用bluebird，这个模块是对原生Promise的一个扩展。

由于是基于Promise实现的流程控制，所以不能像下面这样获取查询值：

user = User.findOne()

console.log(user.get('firstName'));

user是一个promise对象而不是

2. Sequelize类

2.1 new Sequelize() - 实例化

new Sequelize(database, [username=null], [password=null], [options={}])

require引用后，会指向Sequelize的主类的构造函数，引用后就可以通过new关键字进行实例化，实例化后就会以连接池的形式连接到所使用的数据库。语法结构如下：

var Sequelize = require('sequelize');

var sequelize = new Sequelize(database, [username=null], [password=null], [options={}])

实例化Sequelize时，需要传入数据库名、用户名和密码，还可以传入一个可选的options参数对象。

实例化参数

Sequelize实例化示例

// 不使用密码和选项
var sequelize = new Sequelize('database', 'username')

// 不使用选项
var sequelize = new Sequelize('database', 'username', 'password')

// 不使用密码/空密码
var sequelize = new Sequelize('database', 'username', null, {})

// 使用密码和选项
var sequelize = new Sequelize('my_database', 'john', 'doe', {})

Sequelize实例化（初始化）有以上几种形式，通过构造函数实例化后，就可以通过其返回的sequelize实例定义Model、执行query查询、执行transaction等。

2.2 new Sequelize() - 通过URI实例化

new Sequelize(uri, [options={}])

Sequelize可以通过一个URI进行实例化：

// 使用Uri连接
var sequelize = new Sequelize('mysql://localhost:3306/database', {})

2.3 sequelize.models - 实例中已定义的模型

sequelize.models

该实例属性用于返回通过sequelize.define定义的所有模型对象

sequelize.models;
// 返回值如下
{ User: User,
  UserRole: UserRole,
  …… }

2.4 sequelize.define() - 模型定义

sequelize.define(modelName, attributes, [options]) -> Modal

这个实例方法用于定义一个新Model（模型）。Model相当于数据库中的表，该对象不能通过构造函数实例化，而只能通过sequelize.define()或sequelize.import()方法创建。

表中的字段通过第二个参数对象attributes来定义，对象中的一个属性相当于表中的一个字段。

如，可以像下面这样定义一个表：

sequelize.define('modelName', {
    columnA: {
        type: Sequelize.BOOLEAN,
        validate: {
          is: ["[a-z]",'i'],        // will only allow letters
          max: 23,                  // only allow values <= 23
          isIn: {
            args: [['en', 'zh']],
            msg: "Must be English or Chinese"
          }
        },
        field: 'column_a'
        // Other attributes here
    },
    columnB: Sequelize.STRING,
    columnC: 'MY VERY OWN COLUMN TYPE'
})

sequelize.models.modelName // The model will now be available in models under the name given to define

2.5 Sequelize - 顶级对象

var Sequelize = require('sequelize');

Sequelize是一个指向sequelize模块顶级对象引用，同时也是一个构造函数。可以通过该构造函数进行Sequelize类的实例化；也可以通过该对象来访问模块中子对象，如：DataTypes、Errors、Transactions等。

2.6 Utils - 工具类

Sequelize.Utils

一个指定sequelize中工具类的引用，大多数情况下需要直接引用该对象，如：可以使用Sequelize.Utils._属性，该属性是一个指向lodash库的引用，如果你项目中没有另外引用该库就可以通过该属性来调用。

2.7 Promise - Promise对象

Sequelize.Promise

该属性是一个指向bluebirdPromise类型的引用。

2.8 QueryTypes - 查询类型枚举

Sequelize.QueryTypes

用于sequelize.query的表示查询类型的枚举对象。可用类型如下：

module.exports = {
  SELECT: 'SELECT',
  INSERT: 'INSERT',
  UPDATE: 'UPDATE',
  BULKUPDATE: 'BULKUPDATE',
  BULKDELETE: 'BULKDELETE',
  DELETE: 'DELETE',
  UPSERT: 'UPSERT',
  VERSION: 'VERSION',
  SHOWTABLES: 'SHOWTABLES',
  SHOWINDEXES: 'SHOWINDEXES',
  DESCRIBE: 'DESCRIBE',
  RAW: 'RAW',
  FOREIGNKEYS: 'FOREIGNKEYS',
};

2.9 Validator - validator.js对象

Sequelize.Validator

一个指定validator.js对象的引用，该对象用于Sequelize内部的验证，如：非常、URL、IP等，也可以通过该属性进行一些自定义验证。

2.10 Transaction - 事务对象

Sequelize.Transaction

该属性是一个指向SequelizeTransaction类的引用，要以使用这个属性来访问创建事务的隔离级别和事务类型等。

2.11 Deferrable - 延时对象

Sequelize.Deferrable

指向一个延时集合的引用，通过个属必可以访问不通的延时选项。

2.12 Instance - 实例对象

Sequelize.Instance

一个指定Sequelize实例类的引用。

2.13 Association - 联合关系对象

Sequelize.Association

一个指定Association类的引用。

2.14 Error - 错误对象

Sequelize.Error

Sequelize中生成错误的类

2.15 ValidationError - 验证失败错误对象

Sequelize.ValidationError

验证失败时会生成此对象

2.16 DatabaseError - 数据库错误对象

Sequelize.DatabaseError

验证失败时会生成此对象

指向一个所有数据库相关错误的类

2.17 TimeoutError - 查询超时错误对象

Sequelize.TimeoutError

当数据库查询超时时会生成TimeoutError对象。

2.18 UniqueConstraintError - 唯一性错误对象

Sequelize.UniqueConstraintError

当数违反唯一约束时会生成UniqueConstraintError对象。

2.19 ExclusionConstraintError - 排出约束错误对象

Sequelize.ExclusionConstraintError

在数据库中违反排除约束时触发此错误。

2.20 ForeignKeyConstraintError - 外键约束错误对象

Sequelize.ForeignKeyConstraintError

在数据库中违反外键约束时触发此错误。

2.21 ConnectionError - 连接错误对象

Sequelize.ConnectionError

一个指向数据库连接错误时触发的错误对象。

2.22 ConnectionRefusedError - 连接拒绝错误对象

Sequelize.ConnectionRefusedError

一个指向数据库连接被拒绝时触发的错误对象。

2.23 AccessDeniedError - 无访问权限错误对象

Sequelize.AccessDeniedError

连接到数据库但没有访问权限时会触发此错误。

2.24 HostNotFoundError - 主机未找到错误对象

Sequelize.HostNotFoundError

连接数据但主机名（IP或URI）未找到时会触发这个错误对象。

2.25 InvalidConnectionError - 无效链接错误对象

Sequelize.InvalidConnectionError

连接到数据库但其中的任意参数出现错误时会触发这个错误对象。

2.26 ConnectionTimedOutError - 链接超时错误对象

Sequelize.ConnectionTimedOutError

连接数据库超时时会触发这个错误对象。

2.27 InstanceError - 实例错误对象

Sequelize.InstanceError

当任何实例方法出现问题时会触发这个错误对象。

2.28 sequelize.getDialect() - 返回数据库类型

sequelize.getDialect()

该实例方法用于返回实例类型（数据库类型）

2.29 sequelize.getQueryInterface() - 返回QueryInterface实例

sequelize.getQueryInterface()

返回QueryInterface的实例

详见：queryInterface对象及功能

2.30 sequelize.define() - 模型定义

define(modelName, attributes, [options]) -> Model

定义一个模型，该模型是一个建立了与数据表关系的对象

被定义的表中的列在该方法的第二个参数中定义，可以理解为每个属性对应一个表的字段：

sequelize.define('modelName', {
    columnA: {
        type: Sequelize.BOOLEAN,
        validate: {
          is: ["[a-z]",'i'],        // will only allow letters
          max: 23,                  // only allow values <= 23
          isIn: {
            args: [['en', 'zh']],
            msg: "Must be English or Chinese"
          }
        },
        field: 'column_a'
        // Other attributes here
    },
    columnB: Sequelize.STRING,
    columnC: 'MY VERY OWN COLUMN TYPE'
})

sequelize.models.modelName // The model will now be available in models under the name given to define

如上所示，列的定义可以是字符串、一个预定义的Sequelize构造函数、或是一个对象。在定义列时，我们可以指定数据类型，也可以指定默认值、主键/外键等约束，还可以自定义访问器（getter）和设置器（setter）。

参数

2.31 sequelize.model() - 获取模型

sequelize.model(modelName]) -> Model

获取一个已经定义的模型。modelName表示通过sequelize.define定义的模型名。

2.32 sequelize.isDefined() - 检查模型是否定义

sequelize.isDefined(modelName) -> Boolean

检查模型是否已经定义。modelName表示通过sequelize.define定义的模型名。

2.33 sequelize.import() - 模型导入

sequelize.import(path) -> Model

通过文件导入模型定义。检查模型是否已经定义。

被导入的模型会被缓存，所以多次导入并不会重复加载

path表示要导入文件的路径，如果使用相对路径会自动转换为绝对路径。

2.34 sequelize.query() - 执行查询

sequelize.query(sql, [options={}]) -> Promise

执行原始SQL 语句进行查询

默认情况下，返回值中有两个参数：一个包含结果的数组，一个元数据对象。可以通过.spread方法来查看结果。

如果不想使用原始查询结果，可以第二个可选参数中传一个type参数，并指定查询的类型。设置后，sequelize会对结果进行格式化：

sequelize.query('SELECT...').spread(function (results, metadata) {
  // Raw query - use spread
});

sequelize.query('SELECT...', { type: sequelize.QueryTypes.SELECT }).then(function (results) {
  // SELECT query - use then
})

参数

2.35 sequelize.set() - 设置变量

sequelize.set(variables, options) -> Promise

设置一个变量，设置后将会执行基于环境变量或用户变量的查询。此变量会在每次建立连接时设置，仅MySQL 适用。

2.36 sequelize.escape() - 编码

sequelize.escape(value) -> String

对值value进行编码并返回编码结果。

2.37 sequelize.createSchema() - 创建数据库 schema

sequelize.createSchema(schema, options={}) -> Promise

创建一个新的数据库 schema

参数

2.38 sequelize.showAllSchemas() - 查询已定义的schema

sequelize.showAllSchemas(options={}) -> Promise

查询数据库中已定义的schema

参数

2.39 sequelize.dropSchema() - 删除定义的schema

sequelize.dropSchema(schema, options={}) -> Promise

删除数据库中已定义指定名称的schema

参数

2.40 sequelize.dropAllSchemas() - 删除所有schema

sequelize.dropAllSchemas(options={}) -> Promise

删除数据库中所有已定义的schema

参数

2.41 sequelize.sync() - 同步模型到数据库

sequelize.sync([options={}]) -> Promise

同步所有已定义的模型到数据库中

参数

2.42 sequelize.truncate() - 截断已定义的表

sequelize.truncate([options]) -> Promise

截断所有已定义的模型所对应的表，这个操作实际上是调用每个模型的Model.truncate()方法

参数

2.43 sequelize.drop() - 删除表

sequelize.drop(options) -> Promise

删除所有已定义的模型所对应的表，这个操作实际上是调用每个模型的Model.drop()方法

参数

2.44 sequelize.authenticate() - 验证连接

sequelize.authenticate() -> Promise

验证已建立的连接

别名：validate

2.45 sequelize.fn() - 函数调用

sequelize.fn(fn, args) -> Sequelize.fn

创建于一个相当于数据库函数的对象。该函数可用于搜索查询的where和order部分，以及做为列定义的默认值。如果想在列中引用你定义的函数，就要使用sequelize.col，这样列就能正确的解析，而不是解析为字符串。

如，将username字段值解析为大写形式：

instance.updateAttributes({
  username: self.sequelize.fn('upper', self.sequelize.col('username'))
})

2.46 sequelize.col() - 列对象

col(col) -> Sequelize.col

创建一个相当于数据库列的对象。这个方法经常结合sequelize.fn使用，它可以保证将列名正确的传递给该方法，而不是经过转义。

col－表示列名

2.47 sequelize.cast() - cast函数

cast(val, type) -> Sequelize.cast

创建一个表示cast函数调用的对象

• val－{any}，cast的值
• type－{String}，cast类型

2.48 sequelize.literal() - 字面量对象

literal(val) -> Sequelize.literal

创建一个字面量对象，该值不会转义

别名：asIs

更多关于sequelize.literal()的使用请参考：

• 字段值批量自增、自减

2.49 sequelize.and() - AND查询

and(args) -> Sequelize.and

AND查询

• val－{String | Object}，会被AND连接的参数

2.50 sequelize.or() - OR查询

or(args) -> Sequelize.or

OR查询

• val－{String | Object}，会被OR连接的参数

2.51 sequelize.json() - json嵌套对象

json(conditions, [value]) -> Sequelize.json

生成一个Postgre中json类型的嵌套对象

• conditions－{String | Object}，一个能够被postgres json 语法解析以的嵌套对象
• [value]－{String | Object}，可选的比较值，会生成 "<json path> = '<value>'"

2.52 sequelize.where() - 指定WHERE条件

json(conditions, [value]) -> Sequelize.json

指定属性＝条件。

属性也可以从Model.rawAttributes对象获取（如：Model.rawAttributes.id、Model.rawAttributes.name）。属性应该已在模型中定义。也可以从sequelize工具函数中获取（如：sequelize.fn,、sequelize.col

当使用字符串属性是，用于{ where: { attr: something }}语法。如果不希望属性被转义，请使用sequelize.literal。

• attr－{Object}，属性
• [comparator='=']－{String}
• logic－{String ｜ Object}，限制条件可以是简单字符串或进一步的条件对象（如：$or、$and、.litera）

别名：condition

2.53 sequelize.transaction() - 启动事务

sequlize.transaction([options={}]) -> Promise

启动一个事务。当使用事务时，需要将事务做为一个可选参数transaction传入，然后查询就会在传入的事务下执行：

sequelize.transaction().then(function (t) {
  return User.find(..., { transaction: t}).then(function (user) {
    return user.updateAttributes(..., { transaction: t});
  })
  .then(t.commit.bind(t))
  .catch(t.rollback.bind(t));
})

事务支持自动提交或回滚，当使用promise链接调用时会自动完成：

sequelize.transaction(function (t) { 
  // 注意，这时使用的是callback而不是promise.then()
  return User.find(..., { transaction: t}).then(function (user) {
    return user.updateAttributes(..., { transaction: t});
  });
}).then(function () {
  // Committed
}).catch(function (err) {
  // Rolled back
  console.error(err);
});

启用CLS命名空间时，事务分被自动挂载。

var cls = require('continuation-local-storage'),
    ns = cls.createNamespace('....');
var Sequelize = require('sequelize');
Sequelize.cls = ns;