Class Sequelize

View code

This is the main class, the entry point to sequelize. To use it, you just need to import sequelize:

var Sequelize = require('sequelize');

In addition to sequelize, the connection library for the dialect you want to use should also be installed in your project. You don't need to import it however, as sequelize will take care of that.

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

View code

Instantiate sequelize with name of database, username and password

Example usage

// without password and options
var sequelize = new Sequelize('database', 'username')
// without options
var sequelize = new Sequelize('database', 'username', 'password')
// without password / with blank password
var sequelize = new Sequelize('database', 'username', null, {})
// with password and options
var sequelize = new Sequelize('my_database', 'john', 'doe', {})
// with uri (see below)
var sequelize = new Sequelize('mysql://localhost:3306/database', {})

Params:

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

View code

Instantiate sequelize with an URI

Params:

new Sequelize([options={}])

View code

Instantiate sequelize with an options object

Params:

models

View code

Models are stored here under the name given to sequelize.define

version

View code

Sequelize version number.

Sequelize

View code

A reference to Sequelize constructor from sequelize. Useful for accessing DataTypes, Errors etc.

See:

• Sequelize

Utils

View code

A reference to sequelize utilities. Most users will not need to use these utils directly. However, you might want to use Sequelize.Utils._, which is a reference to the lodash library, if you don't already have it imported in your project.

Promise

View code

A handy reference to the bluebird Promise class

QueryTypes

View code

Available query types for use with sequelize.query

Validator

View code

Exposes the validator.js object, so you can extend it with custom validation functions. The validator is exposed both on the instance, and on the constructor.

See:

DataTypes

View code

A reference to the sequelize class holding commonly used data types. The datatypes are used when defining a new model using sequelize.define

Transaction

View code

A reference to the sequelize transaction class. Use this to access isolationLevels and types when creating a transaction

See:

• Transaction
• Sequelize#transaction

Deferrable

View code

A reference to the deferrable collection. Use this to access the different deferrable options.

See:

• Deferrable
• Sequelize#transaction

Instance

View code

A reference to the sequelize instance class.

See:

• Instance

Association

View code

A reference to the sequelize association class.

See:

• Association

Error

View code

A general error class

See:

• Errors#BaseError

ValidationError

View code

Emitted when a validation fails

See:

• Errors#ValidationError

ValidationErrorItem

View code

Describes a validation error on an instance path

See:

• Errors#ValidationErrorItem

DatabaseError

View code

A base class for all database related errors.

See:

• Errors#DatabaseError

TimeoutError

View code

Thrown when a database query times out because of a deadlock

See:

• Errors#TimeoutError

UniqueConstraintError

View code

Thrown when a unique constraint is violated in the database

See:

• Errors#UniqueConstraintError

ExclusionConstraintError

View code

Thrown when an exclusion constraint is violated in the database

See:

• Errors#ExclusionConstraintError

ForeignKeyConstraintError

View code

Thrown when a foreign key constraint is violated in the database

See:

• Errors#ForeignKeyConstraintError

ConnectionError

View code

A base class for all connection related errors.

See:

• Errors#ConnectionError

ConnectionRefusedError

View code

Thrown when a connection to a database is refused

See:

• Errors#ConnectionRefusedError

AccessDeniedError

View code

Thrown when a connection to a database is refused due to insufficient access

See:

• Errors#AccessDeniedError

HostNotFoundError

View code

Thrown when a connection to a database has a hostname that was not found

See:

• Errors#HostNotFoundError

HostNotReachableError

View code

Thrown when a connection to a database has a hostname that was not reachable

See:

• Errors#HostNotReachableError

InvalidConnectionError

View code

Thrown when a connection to a database has invalid values for any of the connection parameters

See:

• Errors#InvalidConnectionError

ConnectionTimedOutError

View code

Thrown when a connection to a database times out

See:

• Errors#ConnectionTimedOutError

InstanceError

View code

Thrown when a some problem occurred with Instance methods (see message for details)

See:

• Errors#InstanceError

EmptyResultError

View code

Thrown when a record was not found, Usually used with rejectOnEmpty mode (see message for details)

See:

• Errors#RecordNotFoundError

getDialect() -> String

View code

Returns the specified dialect.Returns: The specified dialect.

getQueryInterface() -> QueryInterface

View code

Returns an instance of QueryInterface.

See:

• QueryInterface

Returns: An instance (singleton) of QueryInterface.

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

View code

Define a new model, representing a table in the DB.

The table columns are define by the hash that is given as the second argument. Each attribute of the hash represents a column. A short table definition might look like this:

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

As shown above, column definitions can be either strings, a reference to one of the datatypes that are predefined on the Sequelize constructor, or an object that allows you to specify both the type of the column, and other attributes such as default values, foreign key constraints and custom setters and getters.

For a list of possible data types, see http://docs.sequelizejs.com/en/latest/docs/models-definition/#data-types

For more about getters and setters, see http://docs.sequelizejs.com/en/latest/docs/models-definition/#getters-setters

For more about instance and class methods, see http://docs.sequelizejs.com/en/latest/docs/models-definition/#expansion-of-models

For more about validation, see http://docs.sequelizejs.com/en/latest/docs/models-definition/#validations

See:

• DataTypes
• Hooks

Params:

model(modelName) -> Model

View code

Fetch a Model which is already defined

Params:

isDefined(modelName) -> Boolean

View code

Checks whether a model with the given name is defined

Params:

import(path) -> Model

View code

Imports a model defined in another file

Imported models are cached, so multiple calls to import with the same path will not load the file multiple times

See https://github.com/sequelize/express-example for a short example of how to define your models in separate files so that they can be imported by sequelize.import

Params:

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

View code

Execute a query on the DB, with the possibility to bypass all the sequelize goodness.

By default, the function will return two arguments: an array of results, and a metadata object, containing number of affected rows etc. Use .spread to access the results.

If you are running a type of query where you don't need the metadata, for example a SELECT query, you can pass in a query type to make sequelize format the results:

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
})

See:

• Model#build

Params:

set(variables, options) -> Promise

View code

Execute a query which would set an environment or user variable. The variables are set per connection, so this function needs a transaction.Only works for MySQL.

Params:

escape(value) -> String

View code

Escape value.

Params:

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

View code

Create a new database schema.

Note,that this is a schema in the postgres sense of the word,not a database table. In mysql and sqlite, this command will do nothing.

See:

• Model#schema

Params:

showAllSchemas(options={}) -> Promise

View code

Show all defined schemas

Note,that this is a schema in the postgres sense of the word,not a database table. In mysql and sqlite, this will show all tables.

Params:

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

View code

Drop a single schema

Note,that this is a schema in the postgres sense of the word,not a database table. In mysql and sqlite, this drop a table matching the schema name

Params:

dropAllSchemas(options={}) -> Promise

View code

Drop all schemas

Note,that this is a schema in the postgres sense of the word,not a database table. In mysql and sqlite, this is the equivalent of drop all tables.

Params:

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

View code

Sync all defined models to the DB.

Params:

truncate([options]) -> Promise

View code

Truncate all tables defined through the sequelize models. This is doneby calling Model.truncate() on each model.

See:

• Model#truncate

Params:

drop(options) -> Promise

View code

Drop all tables defined through this sequelize instance. This is done by calling Model.drop on each model

See:

• Model#drop

Params:

authenticate() -> Promise

View code

Test the connection by trying to authenticateAliases: validate

fn(fn, args) -> Sequelize.fn

View code

Creates a object representing a database function. This can be used in search queries, both in where and order parts, and as default values in column definitions.If you want to refer to columns in your function, you should use sequelize.col, so that the columns are properly interpreted as columns and not a strings.

Convert a user's username to upper case

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

See:

• Model#find
• Model#findAll
• Model#define
• Sequelize#col

Params:

col(col) -> Sequelize.col

View code

Creates a object representing a column in the DB. This is often useful in conjunction with sequelize.fn, since raw string arguments to fn will be escaped.

See:

• Sequelize#fn

Params:

cast(val, type) -> Sequelize.cast

View code

Creates a object representing a call to the cast function.

Params:

literal(val) -> Sequelize.literal

View code

Creates a object representing a literal, i.e. something that will not be escaped.

Params:

Aliases: asIs

and(args) -> Sequelize.and

View code

An AND query

See:

• Model#find

Params:

or(args) -> Sequelize.or

View code

An OR query

See:

• Model#find

Params:

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

View code

Creates an object representing nested where conditions for postgres's json data-type.

See:

• Model#find

Params:

where(attr, [comparator='='], logic) -> Sequelize.where

View code

A way of specifying attr = condition.

The attr can either be an object taken from Model.rawAttributes (for example Model.rawAttributes.id or Model.rawAttributes.name). Theattribute should be defined in your model definition. The attribute can also be an object from one of the sequelize utility functions (sequelize.fn, sequelize.col etc.)

For string attributes, use the regular { where: { attr: something }} syntax. If you don't want your string to be escaped, use sequelize.literal.

See:

• Model#find

Params:

Aliases: condition

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

View code

Start a transaction. When using transactions, you should pass the transaction in the options argument in order for the query to happen under that 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));
})

A syntax for automatically committing or rolling back based on the promise chain resolution is also supported:

sequelize.transaction(function (t) { // Note that we use a callback rather than a 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);
});

If you have CLS enabled, the transaction will automatically be passed to any query that runs within the callback.To enable CLS, add it do your project, create a namespace and set it on the sequelize constructor:

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

Note, that CLS is enabled for all sequelize instances, and all instances will share the same namespace

See:

• Transaction

Params:

This document is automatically generated based on source code comments. Please do not edit it directly, as your changes will be ignored. Please write on IRC, open an issue or a create a pull request if you feel something can be improved. For help on how to write source code documentation see JSDoc and dox