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 sequlize with an URI

Params:

models

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

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.

See:

• Utils

Promise

View code A modified version of bluebird promises, that allows listening for sql events

See:

• Promise

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:

Transaction

View code A reference to the sequelize transaction class. Use this to access isolationLevels when creating a transaction

See:

• Transaction
• Sequelize#transaction

Instance

View code A reference to the sequelize instance class.

See:

• Instance

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

ForeignKeyConstraintError

View code Thrown when a foreign key constraint is violated in the database

See:

• Errors#ForeignKeyConstraintError

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.

getMigrator([options={}], [force=false]) -> Migrator

View code Returns an instance (singleton) of Migrator.

See:

• Migrator

Params:

Returns: An instance of Migrator.

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://sequelizejs.com/docs/latest/models#data-types

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

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

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

See:

• DataTypes
• Hooks

Params:

model(modelName) -> Model

View code Fetch a DAO factory 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/sequelize/blob/master/examples/using-multiple-model-files/Task.js 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, [callee], [options={}], [replacements]) -> Promise

View code Execute a query on the DB, with the posibility to bypass all the sequelize goodness.

If you do not provide other arguments than the SQL, raw will be assumed to the true, and sequelize will not try to do any formatting to the results of the query.

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:

createSchema(schema) -> 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() -> 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.

dropSchema(schema) -> 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() -> 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.

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

View code Sync all defined DAOs to the DB.

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 authenticate

Aliases: 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). The attribute 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 () {
  // Commited
}).catch(function (err) {
  // Rolled back
  console.error(err);
});

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