Class Model

View code A Model represents a table in the database. Sometimes you might also see it refererred to as model, or simply as factory. This class should not be instantiated directly, it is created using sequelize.define, and already created models can be loaded using sequelize.import

Mixes:

• Hooks
• Associations

removeAttribute([attribute])

View code Remove attribute from model definition

Params:

sync() -> Promise<this>

View code Sync this Model to the DB, that is create the table. Upon success, the callback will be called with the model instance (this)

See:

• Sequelize#sync

drop([options]) -> Promise

View code Drop the table represented by this Model

Params:

schema(schema, [options]) -> this

View code Apply a schema to this model. For postgres, this will actually place the schema in front of the table name - "schema"."tableName", while the schema will be prepended to the table name for mysql and sqlite - 'schema.tablename'.

Params:

getTableName(options) -> String|Object

View code Get the tablename of the model, taking schema into account. The method will return The name as a string if the model has no schema, or an object with tableName, schema and delimiter properties.

Params:

scope(options*) -> Model

View code Apply a scope created in define to the model. First let's look at how to create scopes:

var Model = sequelize.define('model', attributes, {
  defaultScope: {
    where: {
      username: 'dan'
    },
    limit: 12
  },
  scopes: {
    isALie: {
      where: {
        stuff: 'cake'
      }
    },
    complexFunction: function(email, accessLevel) {
      return {
        where: ['email like ? AND access_level >= ?', email + '%', accessLevel]
      }
    },
  }
})

Now, since you defined a default scope, every time you do Model.find, the default scope is appended to your query. Here's a couple of examples:

Model.findAll() // WHERE username = 'dan'
Model.findAll({ where: { age: { gt: 12 } } }) // WHERE age > 12 AND username = 'dan'

To invoke scope functions you can do:

Model.scope({ method: ['complexFunction' '[email protected]', 42]}).findAll()
// WHERE email like '[email protected]%' AND access_level >= 42

Params:

Returns: A reference to the model, with the scope(s) applied. Calling scope again on the returned model will clear the previous scope.

findAll([options], [queryOptions]) -> Promise<Array<Instance>>

View code Search for multiple instances.

Simple search using AND and =

Model.find({
  where: {
    attr1: 42,
    attr2: 'cake'
  }
})

WHERE attr1 = 42 AND attr2 = 'cake'

Using greater than, less than etc.

Model.find({
  where: {
    attr1: {
      gt: 50
    },
    attr2: {
      lte: 45
    },
    attr3: {
      in: [1,2,3]
    },
    attr4: {
      ne: 5
    }
  }
})

WHERE attr1 > 50 AND attr2 <= 45 AND attr3 IN (1,2,3) AND attr4 != 5

Possible options are: gt, gte, lt, lte, ne, between/.., nbetween/notbetween/!.., in, not, like, nlike/notlike

Queries using OR

Model.find({
  where: Sequelize.and(
    { name: 'a project' },
    Sequelize.or(
      { id: [1,2,3] },
      { id: { gt: 10 } }
    )
  )
})

WHERE name = 'a project' AND (id` IN (1,2,3) OR id > 10)

The success listener is called with an array of instances if the query succeeds.

See:

• Sequelize#query

Params:

Aliases: all

findOne([options], [queryOptions]) -> Promise<Instance>

View code Search for a single instance. This applies LIMIT 1, so the listener will always be called with a single instance.

See:

• Model#findAll

Params:

Aliases: find

aggregate(field, aggregateFunction, [options]) -> Promise<options.dataType>

View code Run an aggregation method on the specified field

Params:

count([options]) -> Promise<Integer>

View code Count the number of records matching the provided where clause.

If you provide an include option, the number of matching associations will be counted instead.

Params:

findAndCountAll([findOptions], [queryOptions]) -> Promise<Object>

View code Find all the rows matching your query, within a specified offset / limit, and get the total number of rows matching your query. This is very usefull for paging

Model.findAndCountAll({
  where: ...,
  limit: 12,
  offset: 12
}).success(function (result) {
})

In the above example, result.rows will contain rows 13 through 24, while result.count will return the total number of rows that matched your query.

See:

• Model#findAll

Params:

max(field, [options]) -> Promise<Any>

View code Find the maximum value of field

See:

• Model#aggregate

Params:

min(field, [options]) -> Promise<Any>

View code Find the minimum value of field

See:

• Model#aggregate

Params:

sum(field, [options]) -> Promise<Number>

View code Find the sum of field

See:

• Model#aggregate

Params:

build(values, [options]) -> Instance

View code Builds a new model instance. Values is an object of key value pairs, must be defined but can be empty.

Params:

create(values, [options]) -> Promise<Instance>

View code Builds a new model instance and calls save on it.

See:

• Instance#build
• Instance#save

Params:

(options) -> Promise<Instance>

View code Find a row that matches the query, or build (but don't save) the row if none is found. The successfull result of the promise will be (instance, initialized) - Make sure to use .spread()

Params:

Aliases: findOrBuild

findOrCreate(options, [queryOptions]) -> Promise<Instance|created>

View code Find a row that matches the query, or build and save the row if none is found The successfull result of the promise will be (instance, created) - Make sure to use .spread()

If no transaction is passed in the queryOptions object, a new transaction will be created internally, to prevent the race condition where a matching row is created by another connection after the find but before the insert call. However, it is not always possible to handle this case in SQLite, specifically if one transaction inserts and another tries to select before the first one has comitted. In this case, an instance of sequelize.TimeoutError will be thrown instead. If a transaction is created, a savepoint will be created instead, and any unique constraint violation will be handled internally.

Params:

bulkCreate(records, [options]) -> Promise<Array<Instance>>

View code Create and insert multiple instances in bulk.

The success handler is passed an array of instances, but please notice that these may not completely represent the state of the rows in the DB. This is because MySQL and SQLite do not make it easy to obtain back automatically generated IDs and other default values in a way that can be mapped to multiple records. To obtain Instances for the newly created values, you will need to query for them again.

Params:

destroy() -> Promise<undefined>

View code Delete multiple instances, or set their deletedAt timestamp to the current time if paranoid is enabled.

Params:

restore() -> Promise<undefined>

View code Restore multiple instances if paranoid is enabled.

Params:

update(values, options) -> Promise<Array<affectedCount|affectedRows>>

View code Update multiple instances that match the where options. The promise returns an array with one or two elements. The first element is always the number of affected rows, while the second element is the actual affected rows (only supported in postgres with options.returning true.)

Params:

describe() -> Promise

View code Run a describe query on the table. The result will be return to the listener as a hash of attributes and their types.

dataset() -> node-sql

View code A proxy to the node-sql query builder, which allows you to build your query through a chain of method calls. The returned instance already has all the fields property populated with the field of the model.

See:

Returns: A node-sql instance

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