Class Sequelize

View code

This is the main class, the entry point to sequelize. To use it, you just need to import 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.

View code

Instantiate sequelize with name of database, username and password

Example usage

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={}])

Instantiate sequelize with an options object

Params:

models

View code

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

version

Sequelize version number.

Sequelize

View code

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

See:

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

A handy reference to the bluebird Promise class

QueryTypes

View code

Available query types for use with sequelize.query

Validator

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

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

See:

• Transaction

Deferrable

View code

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

See:

• Sequelize#transaction

Instance

A reference to the sequelize instance class.

See:

• Instance

Association

A reference to the sequelize association class.

See:

• Association

Error

A general error class

See:

• Errors#BaseError

ValidationError

Emitted when a validation fails

See:

• Errors#ValidationError

ValidationErrorItem

Describes a validation error on an instance path

See:

• Errors#ValidationErrorItem

DatabaseError

A base class for all database related errors.

See:

• Errors#DatabaseError

View code

Thrown when a database query times out because of a deadlock

See:

UniqueConstraintError

View code

Thrown when a unique constraint is violated in the database

See:

ExclusionConstraintError

View code

Thrown when an exclusion constraint is violated in the database

See:

ForeignKeyConstraintError

View code

See:

ConnectionError

A base class for all connection related errors.

See:

• Errors#ConnectionError

ConnectionRefusedError

Thrown when a connection to a database is refused

See:

• Errors#ConnectionRefusedError

AccessDeniedError

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

See:

• Errors#AccessDeniedError

HostNotFoundError

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

See:

• Errors#HostNotFoundError

HostNotReachableError

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

See:

• Errors#HostNotReachableError

InvalidConnectionError

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

See:

• Errors#InvalidConnectionError

ConnectionTimedOutError

Thrown when a connection to a database times out

See:

• Errors#ConnectionTimedOutError

InstanceError

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

See:

• Errors#InstanceError

EmptyResultError

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

See:

• Errors#RecordNotFoundError

getDialect() -> String

Returns the specified dialect.Returns: The specified dialect.

getQueryInterface() -> QueryInterface

View code

Returns an instance of QueryInterface.

See:

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:

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

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

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

See:

• Hooks

Params:

model(modelName) -> Model

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

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:

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:

Params:

set(variables, options) -> Promise

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

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:

Params:

showAllSchemas(options={}) -> Promise

View code

Show all defined schemas

Note,that this is a schema in the ,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 ,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 ,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

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

See:

• Model#truncate

Params:

drop(options) -> Promise

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

See:

• Model#drop

Params:

authenticate() -> Promise

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

See:

• Model#findAll
• Sequelize#col

Params:

col(col) -> Sequelize.col

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

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

An AND query

See:

• Model#find

Params:

or(args) -> Sequelize.or

An OR query

See:

• Model#find

Params:

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

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

See:

• Model#find

Params:

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

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

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:

If you have 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:

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 and dox