Interface BelongsToManyAddAssociationsMixinOptions<TModel>

The options for the addAssociations mixin of the belongsToMany association.

See

BelongsToManyAddAssociationsMixin

interface BelongsToManyAddAssociationsMixinOptions<TModel extends Model> {
    association?: boolean;
    attributes?: FindAttributeOptions<Attributes<TModel>>;
    benchmark?: boolean;
    bind?: BindOrReplacements;
    conflictAttributes?: (keyof Attributes<TModel>)[];
    conflictWhere?: WhereOptions<Attributes<TModel>>;
    connection?: AbstractConnection | null;
    fieldMap?: FieldMap;
    fields?: (keyof Attributes<TModel>)[];
    force?: boolean;
    group?: GroupOption;
    groupedLimit?: unknown;
    having?: WhereOptions<any>;
    hooks?: boolean;
    ignoreDuplicates?: boolean;
    include?: AllowArray<Includeable>;
    indexHints?: IndexHint[];
    individualHooks?: boolean;
    instance?: Model<any, any>;
    limit?: number | Nullish | Literal;
    lock?: boolean | Lock | { level: Lock; of: ModelStatic<Model<any, any>> };
    logging?: false | ((sql: string, timing?: number) => void);
    mapToModel?: boolean;
    maxExecutionTimeHintMs?: number;
    minifyAliases?: boolean;
    nest?: boolean;
    offset?: number | Nullish | Literal;
    omitNull?: boolean;
    order?: Order;
    paranoid?: boolean;
    plain?: boolean;
    raw?: boolean;
    rejectOnEmpty?: boolean | Error;
    replacements?: BindOrReplacements;
    reset?: boolean;
    retry?: Options;
    returning?: boolean | (Col | Literal | keyof Attributes<TModel>)[];
    searchPath?: string;
    silent?: boolean;
    skipLocked?: boolean;
    subQuery?: boolean;
    supportsSearchPath?: boolean;
    tableHints?: TableHints[];
    through?: JoinTableAttributes;
    transaction?: Transaction | null;
    type?: string;
    updateOnDuplicate?: (keyof Attributes<TModel>)[];
    useMaster?: boolean;
    validate?: boolean;
    where?: WhereOptions<Attributes<TModel>>;
}

Type Parameters

TModel extends Model

Hierarchy (View Summary)

FindOptions<Attributes<TModel>>
BulkCreateOptions<Attributes<TModel>>
InstanceUpdateOptions<Attributes<TModel>>
InstanceDestroyOptions
- BelongsToManyAddAssociationsMixinOptions

Properties

`Optional`association

association?: boolean

`Optional`attributes

attributes?: FindAttributeOptions<Attributes<TModel>>

If an array: a list of the attributes that you want to select. Attributes can also be raw SQL (literal), fn, col, and cast

To rename an attribute, you can pass an array, with two elements:

The first is the name of the attribute (or literal, fn, col, cast),
and the second is the name to give to that attribute in the returned instance.

If include is used: selects all the attributes of the model, plus some additional ones. Useful for aggregations.

Example

{ attributes: { include: [[literal('COUNT(id)'), 'total']] }

If exclude is used: selects all the attributes of the model, except the one specified in exclude. Useful for security purposes

Example

{ attributes: { exclude: ['password'] } }

`Optional`benchmark

benchmark?: boolean

Pass query execution time in milliseconds as second argument to logging function (options.logging).

`Optional`bind

bind?: BindOrReplacements

Either an object of named parameter bindings in the format $param or an array of unnamed values to bind to $1, $2, etc in your SQL.

`Optional`conflictAttributes

conflictAttributes?: (keyof Attributes<TModel>)[]

Optional override for the conflict fields in the ON CONFLICT part of the query. Only supported in Postgres >= 9.5 and SQLite >= 3.24.0

`Optional`conflictWhere

conflictWhere?: WhereOptions<Attributes<TModel>>

An optional parameter to specify a where clause for partial unique indexes (note: ON CONFLICT WHERE not ON CONFLICT DO UPDATE WHERE). Only supported in Postgres >= 9.5 and sqlite >= 9.5

`Optional`connection

connection?: AbstractConnection | null

The connection on which this query must be run. Mutually exclusive with Transactionable.transaction.

Can be used to ensure that a query is run on the same connection as a previous query, which is useful when configuring session options.

Specifying this option takes precedence over CLS Transactions. If a transaction is running in the current AsyncLocalStorage context, it will be ignored in favor of the specified connection.

`Optional`fieldMap

fieldMap?: FieldMap

Map returned fields to arbitrary names for SELECT query type if options.fieldMaps is present.

`Optional`fields

fields?: (keyof Attributes<TModel>)[]

Fields to insert (defaults to all fields)

`Optional`force

force?: boolean

If set to true, paranoid models will actually be deleted

`Optional`group

group?: GroupOption

GROUP BY in sql

`Optional`groupedLimit

groupedLimit?: unknown

`Optional`having

having?: WhereOptions<any>

Select group rows after groups and aggregates are computed.

`Optional`hooks

hooks?: boolean

If false the applicable hooks will not be called. The default value depends on the context.

Default

true

`Optional`ignoreDuplicates

ignoreDuplicates?: boolean

Ignore duplicate values for primary keys?

Default

false

`Optional`include

include?: AllowArray<Includeable>

A list of associations to eagerly load using a left join (a single association is also supported).

See Includeable to see how to specify the association, and its eager-loading options.

`Optional`indexHints

indexHints?: IndexHint[]

MySQL only.

`Optional`individualHooks

individualHooks?: boolean

Run before / after create hooks for each individual Instance? BulkCreate hooks will still be run if BulkCreateOptions.hooks is true.

Default

false

`Optional`instance

instance?: Model<any, any>

A sequelize instance used to build the return instance

`Optional`limit

limit?: number | Nullish | Literal

Limits how many items will be retrieved by the operation.

If limit and include are used together, Sequelize will turn the subQuery option on by default. This is done to ensure that limit only impacts the Model on the same level as the limit option.

You can disable this behavior by explicitly setting subQuery: false, however limit will then affect the total count of returned values, including eager-loaded associations, instead of just one table.

Example

// in the following query, `limit` only affects the "User" model.
// This will return 2 users, each including all of their projects.
User.findAll({
  limit: 2,
  include: [User.associations.projects],
});

Example

// in the following query, `limit` affects the total number of returned values, eager-loaded associations included.
// This may return 2 users, each with one project,
//  or 1 user with 2 projects.
User.findAll({
  limit: 2,
  include: [User.associations.projects],
  subQuery: false,
});

`Optional`lock

lock?: boolean | Lock | { level: Lock; of: ModelStatic<Model<any, any>> }

Lock the selected rows. Possible options are transaction.LOCK.UPDATE and transaction.LOCK.SHARE. Postgres also supports transaction.LOCK.KEY_SHARE, transaction.LOCK.NO_KEY_UPDATE and specific model locks with joins. See Lock.

`Optional`logging

logging?: false | ((sql: string, timing?: number) => void)

A function that gets executed while running the query to log the sql.

`Optional`mapToModel

mapToModel?: boolean

Map returned fields to model's fields if options.model or options.instance is present. Mapping will occur before building the model instance.

`Optional`maxExecutionTimeHintMs

maxExecutionTimeHintMs?: number

This sets the max execution time for MySQL.

`Optional`minifyAliases

minifyAliases?: boolean

Controls whether aliases are minified in this query. This overrides the global option

`Optional`nest

nest?: boolean

If true, transforms objects with . separated property names into nested objects using dottie.js. For example { 'user.username': 'john' } becomes { user: { username: 'john' }}. When nest is true, the query type is assumed to be 'SELECT', unless otherwise specified

Default

false

`Optional`offset

offset?: number | Nullish | Literal

Skip the first n items of the results.

`Optional`omitNull

omitNull?: boolean

A flag that defines if null values should be passed as values or not.

Default

false

`Optional`order

order?: Order

Specifies an ordering. If a string is provided, it will be escaped.

Using an array, you can provide several attributes / functions to order by. Each element can be further wrapped in a two-element array:

The first element is the column / function to order by,
the second is the direction.

Example

`order: [['name', 'DESC']]`.

The attribute will be escaped, but the direction will not.

`Optional`paranoid

paranoid?: boolean

If true, only non-deleted records will be returned. If false, both deleted and non-deleted records will be returned.

Only applies if InitOptions.paranoid is true for the model.

Default

true

`Optional`plain

plain?: boolean

Sets the query type to SELECT and return a single row

`Optional`raw

raw?: boolean

Return raw result. See Sequelize#query for more information.

`Optional`rejectOnEmpty

rejectOnEmpty?: boolean | Error

Throws an error if the query would return 0 results.

`Optional`replacements

replacements?: BindOrReplacements

Either an object of named parameter replacements in the format :param or an array of unnamed replacements to replace ? in your SQL.

`Optional`reset

reset?: boolean

Clear all previously set data values

`Optional`retry

retry?: Options

`Optional`returning

returning?: boolean | (Col | Literal | keyof Attributes<TModel>)[]

Return all columns or only the specified columns for the affected rows (only for postgres)

`Optional`searchPath

searchPath?: string

An optional parameter to specify the schema search_path (Postgres only)

`Optional`silent

silent?: boolean

If true, the updatedAt timestamp will not be updated.

Default

false

`Optional`skipLocked

skipLocked?: boolean

Skip locked rows. Only supported in Postgres.

`Optional`subQuery

subQuery?: boolean

Use sub queries (internal).

If unspecified, this will true by default if limit is specified, and false otherwise. See FindOptions#limit for more information.

`Optional`supportsSearchPath

supportsSearchPath?: boolean

If false do not prepend the query with the search_path (Postgres only)

`Optional`tableHints

tableHints?: TableHints[]

Use a table hint for the query, only supported in MSSQL.

`Optional`through

through?: JoinTableAttributes

`Optional`transaction

transaction?: Transaction | null

The transaction in which this query must be run. Mutually exclusive with Transactionable.connection.

If the Sequelize disableClsTransactions option has not been set to true, and a transaction is running in the current AsyncLocalStorage context, that transaction will be used, unless null or another Transaction is manually specified here.

`Optional`type

type?: string

The type of query you are executing. The query type affects how results are formatted before they are passed back. The type is a string, but Sequelize.QueryTypes is provided as convenience shortcuts.

`Optional`updateOnDuplicate

updateOnDuplicate?: (keyof Attributes<TModel>)[]

Fields to update if row key already exists (on duplicate key update)? (only supported by MySQL, MariaDB, SQLite >= 3.24.0 & Postgres >= 9.5).

`Optional`useMaster

useMaster?: boolean

Force the query to use the write pool, regardless of the query type.

Default

false

`Optional`validate

validate?: boolean

Should each row be subject to validation before it is inserted. The whole insert will fail if one row fails validation

Default

false

`Optional`where

where?: WhereOptions<Attributes<TModel>>

The WHERE clause. Can be many things from a hash of attributes to raw SQL.

Visit https://sequelize.org/docs/v7/core-concepts/model-querying-basics/ for more information.

Interface BelongsToManyAddAssociationsMixinOptions<TModel>

See

Type Parameters

Hierarchy (View Summary)

Index

Properties

Properties

Optionalassociation

Optionalattributes

Example

Example

Optionalbenchmark

Optionalbind

OptionalconflictAttributes

OptionalconflictWhere

Optionalconnection

OptionalfieldMap

Optionalfields

Optionalforce

Optionalgroup

OptionalgroupedLimit

Optionalhaving

Optionalhooks

Default

OptionalignoreDuplicates

Default

Optionalinclude

OptionalindexHints

OptionalindividualHooks

Default

Optionalinstance

Optionallimit

Example

Example

Optionallock

Optionallogging

OptionalmapToModel

OptionalmaxExecutionTimeHintMs

OptionalminifyAliases

Optionalnest

Default

Optionaloffset

OptionalomitNull

Default

Optionalorder

Example

Optionalparanoid

Default

Optionalplain

Optionalraw

OptionalrejectOnEmpty

Optionalreplacements

Optionalreset

Optionalretry

Optionalreturning

OptionalsearchPath

Optionalsilent

Default

OptionalskipLocked

OptionalsubQuery

OptionalsupportsSearchPath

OptionaltableHints

Optionalthrough

Optionaltransaction

Optionaltype

OptionalupdateOnDuplicate

OptionaluseMaster

Default

Optionalvalidate

Default

Optionalwhere

Settings

On This Page

`Optional`association

`Optional`attributes

`Optional`benchmark

`Optional`bind

`Optional`conflictAttributes

`Optional`conflictWhere

`Optional`connection

`Optional`fieldMap

`Optional`fields

`Optional`force

`Optional`group

`Optional`groupedLimit

`Optional`having

`Optional`hooks

`Optional`ignoreDuplicates

`Optional`include

`Optional`indexHints

`Optional`individualHooks

`Optional`instance

`Optional`limit

`Optional`lock

`Optional`logging

`Optional`mapToModel

`Optional`maxExecutionTimeHintMs

`Optional`minifyAliases

`Optional`nest

`Optional`offset

`Optional`omitNull

`Optional`order

`Optional`paranoid

`Optional`plain

`Optional`raw

`Optional`rejectOnEmpty

`Optional`replacements

`Optional`reset

`Optional`retry

`Optional`returning

`Optional`searchPath

`Optional`silent

`Optional`skipLocked

`Optional`subQuery

`Optional`supportsSearchPath

`Optional`tableHints

`Optional`through

`Optional`transaction

`Optional`type

`Optional`updateOnDuplicate

`Optional`useMaster

`Optional`validate

`Optional`where