createdAt timestamps automatically created by sequelize if timestamps is true
deletedAt timestamps automatically created by sequelize if paranoid is true
Default id automatically created by sequelize
Returns true if this instance has not yet been persisted to the database
A reference to the sequelize instance
updatedAt timestamps automatically created by sequelize if timestamps is true
version number automatically created by sequelize if table options.version is true
A reference to the sequelize instance
Adds relation between specified instances and source instance
Counts related instances (specified by propertyKey) of source instance
Creates instances and relate them to source instance
Returns related instance (specified by propertyKey) of source instance
Checks if specified instances is related to source instance
Removes specified instances from source instance
Sets relation between specified instances and source instance (replaces old relations)
If changed is called with a string it will return a boolean indicating whether the value of that key in
dataValues is different from the value in _previousDataValues.
If changed is called without an argument, it will return an array of keys that have changed.
If changed is called without an argument and no keys have changed, it will return false.
Decrement the value of one or more columns. This is done in the database, which means it does not use the values currently stored on the Instance. The decrement is done using a
SET column = column - X
query. To get the correct value after an decrement into the Instance you should do a reload.
instance.decrement('number') // decrement number by 1
instance.decrement(['number', 'count'], { by: 2 }) // decrement number and count by 2
instance.decrement({ answer: 42, tries: 1}, { by: 2 }) // decrement answer by 42, and tries by 1.
// `by` is ignored, since each column has its own
// value
If a string is provided, that column is decremented by the value of by given in options.
If an array is provided, the same is true for each column.
If an object is provided, each column is decremented by the value given
Destroy the row corresponding to this instance. Depending on your setting for paranoid, the row will either be completely deleted, or have its deletedAt timestamp set to the current time.
Check whether all values of this and other Instance are the same
Check if this is eqaul to one of others by calling equals
If no key is given, returns all values of the instance, also invoking virtual getters.
If key is given and a field or virtual getter is present for the key it will call that getter - else it will return the value for key.
If set to true, included instances will be returned as plain objects
Get the value of the underlying data value
Increment the value of one or more columns. This is done in the database, which means it does not use the values currently stored on the Instance. The increment is done using a
SET column = column + X
query. To get the correct value after an increment into the Instance you should do a reload.
instance.increment('number') // increment number by 1
instance.increment(['number', 'count'], { by: 2 }) // increment number and count by 2
instance.increment({ answer: 42, tries: 1}, { by: 2 }) // increment answer by 42, and tries by 1.
// `by` is ignored, since each column has its own
// value
If a string is provided, that column is incremented by the value of by given in options.
If an array is provided, the same is true for each column.
If an object is provided, each column is incremented by the value given.
Returns the previous value for key from _previousDataValues.
Refresh the current instance in-place, i.e. update the object with current data from the DB and return
the same object. This is different from doing a find(Instance.id), because that would create and
return a new instance. With this method, all references to the Instance are updated with the new data
and no new objects are created.
Restore the row corresponding to this instance. Only available for paranoid models.
Validate this instance, and if the validation passes, persist it to the database.
On success, the callback will be called with this instance. On validation error, the callback will be
called with an instance of Sequelize.ValidationError. This error will have a property for each of the
fields for which validation failed, with the error message for that field.
Set is used to update values on the instance (the sequelize representation of the instance that is,
remember that nothing will be persisted before you actually call save). In its most basic form set
will update a value stored in the underlying dataValues object. However, if a custom setter function
is defined for the key, that function will be called instead. To bypass the setter, you can pass raw:
true in the options object.
If set is called with an object, it will loop over the object, and call set recursively for each key, value pair. If you set raw to true, the underlying dataValues will either be set directly to the object passed, or used to extend dataValues, if dataValues already contain values.
When set is called, the previous value of the field is stored and sets a changed flag(see changed).
Set can also be used to build instances for associations, if you have values for those. When using set with associations you need to make sure the property key matches the alias of the association while also making sure that the proper include options have been set (from .build() or .find())
If called with a dot.seperated key on a JSON/JSONB attribute it will set the value nested and flag the entire object as changed.
Update the underlying data value
Convert the instance to a JSON representation. Proxies to calling get with no keys. This means get all
values gotten from the DB, and apply all custom getters.
This is the same as calling set and then calling save.
Validate the attribute of this instance according to validation rules set in the model definition.
Emits null if and only if validation successful; otherwise an Error instance containing { field name : [error msgs] } entries.
An array of strings. All properties that are in this array will not be validated
Get an object representing the query for this instance, use with options.where
Add a hook to the model
Provide a name for the hook function. It can be used to remove the hook later or to order hooks based on some sort of priority system in the future.
The hook function
Add a new scope to the model. This is especially useful for adding scopes with includes, when the model you want to include is not available at the time this model is defined.
By default this will throw an error if a scope with that name already exists. Pass override: true in the options object to silence this error.
The name of the scope. Use defaultScope to override the default scope
A hook that is run after creating instances in bulk
A callback function that is called with instances, options
A hook that is run after destroying instances in bulk
A callback function that is called with options
A hook that is run after sequelize.sync call
A callback function that is called with options passed to sequelize.sync
A hook that is run after updating instances in bulk
A callback function that is called with options
A hook that is run after creating a single instance
A callback function that is called with attributes, options
A hook that is run after a define call
A callback function that is called with factory
A hook that is run after destroying a single instance
A callback function that is called with instance, options
A hook that is run after a find (select) query
A callback function that is called with instance(s), options
A hook that is run after Sequelize() call
A callback function that is called with sequelize
A hook that is run after Model.sync call
A callback function that is called with options passed to Model.sync
A hook that is run after updating a single instance
A callback function that is called with instance, options
A hook that is run after validation
A callback function that is called with instance, options
Run an aggregation method on the specified field
The field to aggregate over. Can be a field name or *
The function to use for aggregation, e.g. sum, max etc.
Query options. See sequelize.query for full options
Returns the aggregate result cast to options.dataType, unless options.plain is false, in
which case the complete data result is returned.
A hook that is run before creating instances in bulk
A callback function that is called with instances, options
A hook that is run before destroying instances in bulk
A callback function that is called with options
A hook that is run before sequelize.sync call
A callback function that is called with options passed to sequelize.sync
A hook that is run after updating instances in bulk
A callback function that is called with options
A hook that is run before creating a single instance
A callback function that is called with attributes, options
A hook that is run before a define call
A callback function that is called with attributes, options
A hook that is run before destroying a single instance
A callback function that is called with instance, options
A hook that is run before a find (select) query
A callback function that is called with options
A hook that is run before a find (select) query, after any { include: {all: ...} } options are expanded
A callback function that is called with options
A hook that is run before a find (select) query, after all option parsing is complete
A callback function that is called with options
A hook that is run before Sequelize() call
A callback function that is called with config, options
A hook that is run before Model.sync call
A callback function that is called with options passed to Model.sync
A hook that is run before updating a single instance
A callback function that is called with instance, options
A hook that is run before validation
A callback function that is called with instance, options
Builds a new model instance. Values is an object of key value pairs, must be defined but can be empty.
Undocumented bulkBuild
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.
List of objects (key/value pairs) to create instances from
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.
Builds a new model instance and calls save on it.
Run a describe query on the table. The result will be return to the listener as a hash of attributes and their types.
Delete multiple instances, or set their deletedAt timestamp to the current time if paranoid is enabled.
Promise
Drop the table represented by this Model
Search for multiple instances.
Simple search using AND and =
Model.findAll({
where: {
attr1: 42,
attr2: 'cake'
}
})
WHERE attr1 = 42 AND attr2 = 'cake'
Using greater than, less than etc.
Model.findAll({
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: $ne, $in, $not, $notIn, $gte, $gt, $lte, $lt, $like, $ilike/$iLike, $notLike,
$notILike, '..'/$between, '!..'/$notBetween, '&&'/$overlap, '@>'/$contains, '<@'/$contained
Queries using OR
Model.findAll({
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.
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
}).then(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.
When you add includes, only those which are required (either because they have a where clause, or
because
required is explicitly set to true on the include) will be added to the count part.
Suppose you want to find all users who have a profile attached:
User.findAndCountAll({
include: [
{ model: Profile, required: true}
],
limit 3
});
Because the include for Profile has required set it will result in an inner join, and only the users
who have a profile will be counted. If we remove required from the include, both users with and
without
profiles will be counted
Search for a single instance by its primary key. This applies LIMIT 1, so the listener will always be called with a single instance.
A more performant findOrCreate that will not work under a transaction (at least not in postgres) Will execute a find call, if empty then attempt to create, if unique constraint then attempt to find again
Search for a single instance. This applies LIMIT 1, so the listener will always be called with a single instance.
Find a row that matches the query, or build and save the row if none is found The successful result of the promise will be (instance, created) - Make sure to use .spread()
If no transaction is passed in the options 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.
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()
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.
The hash of options from any query. You can use one model to access tables with matching
schemas by overriding getTableName and using custom key/values to alter the name of the table.
(eg.
subscribers_1, subscribers_2)
Check whether the mode has any hooks of this type
Increment the value of one or more columns. This is done in the database, which means it does not use the values currently stored on the Instance. The increment is done using a
SET column = column + X WHERE foo = 'bar'
query. To get the correct value after an increment into the Instance you should do a reload.
Model.increment('number', { where: { foo: 'bar' }) // increment number by 1
Model.increment(['number', 'count'], { by: 2, where: { foo: 'bar' } }) // increment number and count by 2
Model.increment({ answer: 42, tries: -1}, { by: 2, where: { foo: 'bar' } }) // increment answer by 42, and decrement tries by 1.
// `by` is ignored, since each column has its own value
If a string is provided, that column is incremented by the value of by given in options.
If an array is provided, the same is true for each column.
If an object is provided, each column is incremented by the value given.
Find the maximum value of field
Find the minimum value of field
Remove attribute from model definition
Remove hook from the model
Restore multiple instances if paranoid is enabled.
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'.The name of the schema
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: email
},
accesss_level {
$gte: 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' 'dan@sequelize.com', 42]}).findAll()
// WHERE email like 'dan@sequelize.com%' AND access_level >= 42
Model A reference to the model, with the scope(s) applied. Calling scope again on the returned model will clear the previous scope.
Find the sum of field
Sync this Model to the DB, that is create the table. Upon success, the callback will be called with the model instance (this)
Truncate all instances of the model. This is a convenient method for Model.destroy({ truncate: true }).
Unscope the model
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.)
Insert or update a single row. An update will be executed if a row which matches the supplied values on either the primary key or a unique key is found. Note that the unique index must be defined in your sequelize model and not just in the table. Otherwise you may experience a unique constraint violation, because sequelize fails to identify the row that should be updated.
Implementation details:
INSERT values ON DUPLICATE KEY UPDATE valuesINSERT; UPDATE. This means that the update is executed
regardless
of whether the row already existed or notNote that SQLite returns undefined for created, no matter if the row was created or updated. This is because SQLite always runs INSERT OR IGNORE + UPDATE, in a single query, so there is no way to know whether the row was inserted or not.
Generated using TypeDoc
Returns the Model the instance was created from.
Model