Class AbstractQueryInterface<Dialect>

This interface exposes low-level APIs to interact with the database. Typically useful in contexts where models are not available, such as migrations.

This interface is available through Sequelize#queryInterface.

Type Parameters

Dialect extends AbstractDialect = AbstractDialect

Hierarchy (View Summary)

AbstractQueryInterfaceTypeScript<Dialect>
- AbstractQueryInterface

Index

Constructors

constructor

new AbstractQueryInterface<
    Dialect extends
        AbstractDialect<object, object> = AbstractDialect<object, object>,
>(
    dialect: Dialect,
    internalQueryInterface?: AbstractQueryInterfaceInternal,
): AbstractQueryInterface<Dialect>
Type Parameters
- Dialect extends AbstractDialect<object, object> = AbstractDialect<object, object>
Parameters
- dialect: Dialect
  The dialect instance.
- OptionalinternalQueryInterface: AbstractQueryInterfaceInternal
  The internal query interface to use. Defaults to a new instance of AbstractQueryInterfaceInternal. Your dialect may replace this with a custom implementation.
Returns AbstractQueryInterface<Dialect>
Inherited from AbstractQueryInterfaceTypeScript.constructor
- Defined in packages/core/src/abstract-dialect/query-interface-typescript.ts:71

Properties

`Readonly`dialect

dialect: Dialect

Accessors

queryGenerator

get queryGenerator(): Dialect["queryGenerator"]
Returns Dialect["queryGenerator"]
Inherited from AbstractQueryInterfaceTypeScript.queryGenerator
- Defined in packages/core/src/abstract-dialect/query-interface-typescript.ts:81

sequelize

get sequelize(): Sequelize<Dialect>
Returns Sequelize<Dialect>
Inherited from AbstractQueryInterfaceTypeScript.sequelize
- Defined in packages/core/src/abstract-dialect/query-interface-typescript.ts:77

Methods

_commitTransaction

_commitTransaction(
transaction: Transaction,
options: CommitTransactionOptions,
): Promise<void>
Commit an already started transaction.

This is an internal method used by sequelize.transaction() use at your own risk.
Parameters
- transaction: Transaction
- options: CommitTransactionOptions
Returns Promise<void>
Inherited from AbstractQueryInterfaceTypeScript._commitTransaction
- Defined in packages/core/src/abstract-dialect/query-interface-typescript.ts:782

_createSavepoint

_createSavepoint(
transaction: Transaction,
options: CreateSavepointOptions,
): Promise<void>
Create a new savepoint.

This is an internal method used by sequelize.transaction() use at your own risk.
Parameters
- transaction: Transaction
- options: CreateSavepointOptions
Returns Promise<void>
Inherited from AbstractQueryInterfaceTypeScript._createSavepoint
- Defined in packages/core/src/abstract-dialect/query-interface-typescript.ts:807

_rollbackSavepoint

_rollbackSavepoint(
transaction: Transaction,
options: RollbackSavepointOptions,
): Promise<void>
Rollback to a savepoint.

This is an internal method used by sequelize.transaction() use at your own risk.
Parameters
- transaction: Transaction
- options: RollbackSavepointOptions
Returns Promise<void>
Inherited from AbstractQueryInterfaceTypeScript._rollbackSavepoint
- Defined in packages/core/src/abstract-dialect/query-interface-typescript.ts:828

_rollbackTransaction

_rollbackTransaction(
transaction: Transaction,
options: RollbackTransactionOptions,
): Promise<void>
Rollback (revert) a transaction that hasn't been committed.

This is an internal method used by sequelize.transaction() use at your own risk.
Parameters
- transaction: Transaction
- options: RollbackTransactionOptions
Returns Promise<void>
Inherited from AbstractQueryInterfaceTypeScript._rollbackTransaction
- Defined in packages/core/src/abstract-dialect/query-interface-typescript.ts:857

_setIsolationLevel

_setIsolationLevel(
transaction: Transaction,
options: SetIsolationLevelOptions,
): Promise<void>
Set the isolation level of a transaction.

This is an internal method used by sequelize.transaction() use at your own risk.
Parameters
- transaction: Transaction
- options: SetIsolationLevelOptions
Returns Promise<void>
Inherited from AbstractQueryInterfaceTypeScript._setIsolationLevel
- Defined in packages/core/src/abstract-dialect/query-interface-typescript.ts:882

_startTransaction

_startTransaction(
transaction: Transaction,
options: StartTransactionOptions,
): Promise<void>
Begin a new transaction.

This is an internal method used by sequelize.transaction() use at your own risk.
Parameters
- transaction: Transaction
- options: StartTransactionOptions
Returns Promise<void>
Inherited from AbstractQueryInterfaceTypeScript._startTransaction
- Defined in packages/core/src/abstract-dialect/query-interface-typescript.ts:910

addColumn

addColumn(
    table: TableName,
    key: string,
    attribute: DataType | AttributeOptions<Model<any, any>>,
    options?: AddColumnOptions,
): Promise<void>
Adds a new column to a table
Parameters
- table: TableName
- key: string
- attribute: DataType | AttributeOptions<Model<any, any>>
- Optionaloptions: AddColumnOptions
Returns Promise<void>
- Defined in packages/core/src/abstract-dialect/query-interface.d.ts:258

addConstraint

addConstraint(
tableName: TableOrModel,
options: AddConstraintOptions,
): Promise<void>

Add a constraint to a table

Available constraints:

UNIQUE
DEFAULT (MSSQL only)
CHECK (Not supported by MySQL)
FOREIGN KEY
PRIMARY KEY

Parameters

tableName: TableOrModel
Table name where you want to add a constraint
options: AddConstraintOptions
An object to define the constraint name, type etc

Returns Promise<void>

Example: UNIQUE

queryInterface.addConstraint('Users', {
  fields: ['email'],
  type: 'UNIQUE',
  name: 'custom_unique_constraint_name'
});

Example: CHECK

queryInterface.addConstraint('Users', {
  fields: ['roles'],
  type: 'CHECK',
  where: {
     roles: ['user', 'admin', 'moderator', 'guest']
  }
});

Example: Default - MSSQL only

queryInterface.addConstraint('Users', {
   fields: ['roles'],
   type: 'DEFAULT',
   defaultValue: 'guest'
});

Example: Primary Key

queryInterface.addConstraint('Users', {
   fields: ['username'],
   type: 'PRIMARY KEY',
   name: 'custom_primary_constraint_name'
});

Example: Composite Primary Key

queryInterface.addConstraint('Users', {
   fields: ['first_name', 'last_name'],
   type: 'PRIMARY KEY',
   name: 'custom_primary_constraint_name'
});

Example: Foreign Key

queryInterface.addConstraint('Posts', {
  fields: ['username'],
  type: 'FOREIGN KEY',
  name: 'custom_fkey_constraint_name',
  references: { //Required field
    table: 'target_table_name',
    field: 'target_column_name'
  },
  onDelete: 'cascade',
  onUpdate: 'cascade'
});

Example: Composite Foreign Key

queryInterface.addConstraint('TableName', {
  fields: ['source_column_name', 'other_source_column_name'],
  type: 'FOREIGN KEY',
  name: 'custom_fkey_constraint_name',
  references: { //Required field
    table: 'target_table_name',
    fields: ['target_column_name', 'other_target_column_name']
  },
  onDelete: 'cascade',
  onUpdate: 'cascade'
});

addIndex

addIndex(
    tableName: TableOrModel,
    attributes: string[],
    options?: QueryInterfaceIndexOptions,
    rawTablename?: string,
): Promise<void>
Adds a new index to a table
Parameters
- tableName: TableOrModel
- attributes: string[]
- Optionaloptions: QueryInterfaceIndexOptions
- OptionalrawTablename: string
Returns Promise<void>
- Defined in packages/core/src/abstract-dialect/query-interface.d.ts:288
addIndex(
    tableName: TableOrModel,
    options: {
        benchmark?: boolean;
        bind?: BindOrReplacements;
        concurrently?: boolean;
        connection?: null | AbstractConnection;
        fieldMap?: FieldMap;
        fields: (string | Fn | Literal | IndexField)[];
        include?: Literal | (string | Literal)[];
        instance?: Model<any, any>;
        logging?: false | (sql: string, timing?: number) => void;
        mapToModel?: boolean;
        msg?: string;
        name?: string;
        nest?: boolean;
        operator?: string;
        parser?: null | string;
        plain?: boolean;
        prefix?: string;
        raw?: boolean;
        replacements?: { [key: string]: unknown };
        retry?: Options;
        supportsSearchPath?: boolean;
        transaction?: null | Transaction;
        type?: IndexType;
        unique?: boolean;
        useMaster?: boolean;
        using?: string;
        where?: WhereOptions;
    },
    rawTablename?: string,
): Promise<void>
Adds a new index to a table
Parameters
- tableName: TableOrModel
- options: {
      benchmark?: boolean;
      bind?: BindOrReplacements;
      concurrently?: boolean;
      connection?: null | AbstractConnection;
      fieldMap?: FieldMap;
      fields: (string | Fn | Literal | IndexField)[];
      include?: Literal | (string | Literal)[];
      instance?: Model<any, any>;
      logging?: false | (sql: string, timing?: number) => void;
      mapToModel?: boolean;
      msg?: string;
      name?: string;
      nest?: boolean;
      operator?: string;
      parser?: null | string;
      plain?: boolean;
      prefix?: string;
      raw?: boolean;
      replacements?: { [key: string]: unknown };
      retry?: Options;
      supportsSearchPath?: boolean;
      transaction?: null | Transaction;
      type?: IndexType;
      unique?: boolean;
      useMaster?: boolean;
      using?: string;
      where?: WhereOptions;
  }
  - Optionalbenchmark?: boolean
    Pass query execution time in milliseconds as second argument to logging function (options.logging).
  - Optionalbind?: 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.
  - Optionalconcurrently?: boolean
    PostgreSQL will build the index without taking any write locks. Postgres only.
    
    Default
    false
  - Optionalconnection?: null | AbstractConnection
    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.
  - OptionalfieldMap?: FieldMap
    Map returned fields to arbitrary names for SELECT query type if options.fieldMaps is present.
  - fields: (string | Fn | Literal | IndexField)[]
    The fields to index.
  - Optionalinclude?: Literal | (string | Literal)[]
    Non-key columns to be added to the lead level of the nonclustered index.
  - Optionalinstance?: Model<any, any>
    A sequelize instance used to build the return instance
  - Optionallogging?: false | (sql: string, timing?: number) => void
    A function that gets executed while running the query to log the sql.
  - OptionalmapToModel?: boolean
    Map returned fields to model's fields if options.model or options.instance is present. Mapping will occur before building the model instance.
  - Optionalmsg?: string
    The message to display if the unique constraint is violated.
  - Optionalname?: string
    The name of the index. Defaults to model name + _ + fields concatenated
  - Optionalnest?: 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
  - Optionaloperator?: string
    Index operator type. Postgres only
  - Optionalparser?: null | string
    For FULLTEXT columns set your parser
  - Optionalplain?: boolean
    Sets the query type to SELECT and return a single row
  - Optionalprefix?: string
    Prefix to append to the index name.
  - Optionalraw?: boolean
    If true, sequelize will not try to format the results of the query, or build an instance of a model from the result
  - Optionalreplacements?: { [key: string]: unknown }
    Only named replacements are allowed in query interface methods.
  - Optionalretry?: Options
  - OptionalsupportsSearchPath?: boolean
    If false do not prepend the query with the search_path (Postgres only)
  - Optionaltransaction?: null | Transaction
    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.
  - Optionaltype?: IndexType
    Index type. Only used by mysql. One of UNIQUE, FULLTEXT and SPATIAL
  - Optionalunique?: boolean
    Should the index by unique? Can also be triggered by setting type to UNIQUE
    
    Default
    false
  - OptionaluseMaster?: boolean
    Force the query to use the write pool, regardless of the query type.
    
    Default
    false
  - Optionalusing?: string
    The method to create the index by (USING statement in SQL). BTREE and HASH are supported by mysql and postgres. Postgres additionally supports GIST, SPGIST, BRIN and GIN.
  - Optionalwhere?: WhereOptions
    Optional where parameter for index. Can be used to limit the index to certain rows.
- OptionalrawTablename: string
Returns Promise<void>
- Defined in packages/core/src/abstract-dialect/query-interface.d.ts:294

assertTableHasColumn

assertTableHasColumn(
    tableName: TableOrModel,
    columnName: string,
    options?: QueryRawOptions,
): Promise<ColumnsDescription>
Parameters
- tableName: TableOrModel
- columnName: string
- Optionaloptions: QueryRawOptions
Returns Promise<ColumnsDescription>
- Defined in packages/core/src/abstract-dialect/query-interface.d.ts:500

bulkDelete

bulkDelete(
tableOrModel: TableOrModel,
options?: QiBulkDeleteOptions<any>,
): Promise<number>
Deletes records from a table
Parameters
- tableOrModel: TableOrModel
- Optionaloptions: QiBulkDeleteOptions<any>
Returns Promise<number>
Inherited from AbstractQueryInterfaceTypeScript.bulkDelete
- Defined in packages/core/src/abstract-dialect/query-interface-typescript.ts:943

bulkInsert

bulkInsert(
    tableName: TableName,
    records: object[],
    options?: QiOptionsWithReplacements,
    attributes?: Record<string, AttributeOptions<Model<any, any>>>,
): Promise<number | object>
Inserts multiple records at once
Parameters
- tableName: TableName
- records: object[]
- Optionaloptions: QiOptionsWithReplacements
- Optionalattributes: Record<string, AttributeOptions<Model<any, any>>>
Returns Promise<number | object>
- Defined in packages/core/src/abstract-dialect/query-interface.d.ts:348

bulkUpdate

bulkUpdate(
    tableName: TableName,
    values: object,
    where: WhereOptions<any>,
    options?: QiOptionsWithReplacements,
    columnDefinitions?: {
        [columnName: string]: NormalizedAttributeOptions<Model<any, any>>;
    },
): Promise<object>
Updates multiple rows at once
Parameters
- tableName: TableName
- values: object
- where: WhereOptions<any>
- Optionaloptions: QiOptionsWithReplacements
- OptionalcolumnDefinitions: { [columnName: string]: NormalizedAttributeOptions<Model<any, any>> }
Returns Promise<object>
- Defined in packages/core/src/abstract-dialect/query-interface.d.ts:369

changeColumn

changeColumn(
    tableName: TableName,
    attributeName: string,
    dataTypeOrOptions?: DataType | AttributeOptions<Model<any, any>>,
    options?: QiOptionsWithReplacements,
): Promise<void>
Changes a column
Parameters
- tableName: TableName
- attributeName: string
- OptionaldataTypeOrOptions: DataType | AttributeOptions<Model<any, any>>
- Optionaloptions: QiOptionsWithReplacements
Returns Promise<void>
- Defined in packages/core/src/abstract-dialect/query-interface.d.ts:268

createDatabase

createDatabase(database: string, options?: CreateDatabaseOptions): Promise<void>
Create a database
Parameters
- database: string
- Optionaloptions: CreateDatabaseOptions
Returns Promise<void>
Inherited from AbstractQueryInterfaceTypeScript.createDatabase
- Defined in packages/core/src/abstract-dialect/query-interface-typescript.ts:91

createFunction

createFunction(
    functionName: string,
    params: FunctionParam[],
    returnType: string,
    language: string,
    body: string,
    optionsArray?: string[],
    options?: CreateFunctionOptions,
): Promise<void>
Postgres only. Create a function
Parameters
- functionName: string
- params: FunctionParam[]
- returnType: string
- language: string
- body: string
- OptionaloptionsArray: string[]
- Optionaloptions: CreateFunctionOptions
Returns Promise<void>
- Defined in packages/core/src/abstract-dialect/query-interface.d.ts:459

createSchema

createSchema(schema: string, options?: CreateSchemaOptions): Promise<void>
Create a new database schema.

Note: We define schemas as a namespace that can contain tables. In mysql and mariadb, this command will create what they call a database.
Parameters
- schema: string
  Name of the schema
- Optionaloptions: CreateSchemaOptions
Returns Promise<void>
Inherited from AbstractQueryInterfaceTypeScript.createSchema
- Defined in packages/core/src/abstract-dialect/query-interface-typescript.ts:150

createTable

createTable<M extends Model<any, any>>(
    tableName: TableName,
    attributes: CreateTableAttributes<M, CreationAttributes<M>>,
    options?: QueryInterfaceCreateTableOptions,
): Promise<void>
Creates a table with specified attributes.
Type Parameters
- M extends Model<any, any>
Parameters
- tableName: TableName
  Name of table to create
- attributes: CreateTableAttributes<M, CreationAttributes<M>>
  Hash of attributes, key is attribute name, value is data type
- Optionaloptions: QueryInterfaceCreateTableOptions
  Table options.
Returns Promise<void>
- Defined in packages/core/src/abstract-dialect/query-interface.d.ts:242

createTrigger

createTrigger(
    tableName: TableName,
    triggerName: string,
    timingType: string,
    fireOnArray: { [key: string]: unknown }[],
    functionName: string,
    functionParams: FunctionParam[],
    optionsArray: string[],
    options?: QiOptionsWithReplacements,
): Promise<void>
Postgres only. Creates a trigger on specified table to call the specified function with supplied parameters.
Parameters
- tableName: TableName
- triggerName: string
- timingType: string
- fireOnArray: { [key: string]: unknown }[]
- functionName: string
- functionParams: FunctionParam[]
- optionsArray: string[]
- Optionaloptions: QiOptionsWithReplacements
Returns Promise<void>
- Defined in packages/core/src/abstract-dialect/query-interface.d.ts:424

decrement

decrement<M extends Model<any, any>>(
    model: ModelStatic<M>,
    tableName: TableName,
    where: WhereOptions<Attributes<M>>,
    decrementAmountsByField: object,
    extraAttributesToBeUpdated: object,
    options?: QiArithmeticOptions,
): Promise<object>
Decrements a row value
Type Parameters
- M extends Model<any, any>
Parameters
- model: ModelStatic<M>
- tableName: TableName
- where: WhereOptions<Attributes<M>>
- decrementAmountsByField: object
- extraAttributesToBeUpdated: object
- Optionaloptions: QiArithmeticOptions
Returns Promise<object>
- Defined in packages/core/src/abstract-dialect/query-interface.d.ts:401

deferConstraints

deferConstraints(
constraintChecking: ConstraintChecking,
options?: DeferConstraintsOptions,
): Promise<void>
Parameters
- constraintChecking: ConstraintChecking
- Optionaloptions: DeferConstraintsOptions
Returns Promise<void>
Inherited from AbstractQueryInterfaceTypeScript.deferConstraints
- Defined in packages/core/src/abstract-dialect/query-interface-typescript.ts:557

describeTable

describeTable(
tableName: TableOrModel,
options?: DescribeTableOptions,
): Promise<ColumnsDescription>
Describe a table structure

This method returns an array of hashes containing information about all attributes in the table.
```
{
   name: {
     type:         'VARCHAR(255)', // this will be 'CHARACTER VARYING' for pg!
     allowNull:    true,
     defaultValue: null
   },
   isBetaMember: {
     type:         'TINYINT(1)', // this will be 'BOOLEAN' for pg!
     allowNull:    false,
     defaultValue: false
   }
}
```
Parameters
- tableName: TableOrModel
- Optionaloptions: DescribeTableOptions
  Query options
Returns Promise<ColumnsDescription>
Inherited from AbstractQueryInterfaceTypeScript.describeTable
- Defined in packages/core/src/abstract-dialect/query-interface-typescript.ts:361

dropAllEnums

dropAllEnums(options?: QueryRawOptions): Promise<void>
Drops all defined enums
Parameters
- Optionaloptions: QueryRawOptions
Returns Promise<void>
- Defined in packages/core/src/abstract-dialect/query-interface.d.ts:253

dropAllSchemas

dropAllSchemas(options?: QiDropAllSchemasOptions): Promise<void>
Drops all schemas
Parameters
- Optionaloptions: QiDropAllSchemasOptions
Returns Promise<void>
Inherited from AbstractQueryInterfaceTypeScript.dropAllSchemas
- Defined in packages/core/src/abstract-dialect/query-interface-typescript.ts:174

dropAllTables

dropAllTables(options?: QiDropAllTablesOptions): Promise<void>
Drop all tables
Parameters
- Optionaloptions: QiDropAllTablesOptions
Returns Promise<void>
Inherited from AbstractQueryInterfaceTypeScript.dropAllTables
- Defined in packages/core/src/abstract-dialect/query-interface-typescript.ts:250

dropDatabase

dropDatabase(database: string, options?: QueryRawOptions): Promise<void>
Drop a database
Parameters
- database: string
- Optionaloptions: QueryRawOptions
Returns Promise<void>
Inherited from AbstractQueryInterfaceTypeScript.dropDatabase
- Defined in packages/core/src/abstract-dialect/query-interface-typescript.ts:103

dropFunction

dropFunction(
    functionName: string,
    params: FunctionParam[],
    options?: QiOptionsWithReplacements,
): Promise<void>
Postgres only. Drops a function
Parameters
- functionName: string
- params: FunctionParam[]
- Optionaloptions: QiOptionsWithReplacements
Returns Promise<void>
- Defined in packages/core/src/abstract-dialect/query-interface.d.ts:472

dropSchema

dropSchema(schema: string, options?: DropSchemaOptions): Promise<void>
Drop a single schema

Note: We define schemas as a namespace that can contain tables. In mysql and mariadb, this command will create what they call a database.
Parameters
- schema: string
  Name of the schema
- Optionaloptions: DropSchemaOptions
Returns Promise<void>
Inherited from AbstractQueryInterfaceTypeScript.dropSchema
- Defined in packages/core/src/abstract-dialect/query-interface-typescript.ts:164

dropTable

dropTable(tableName: TableOrModel, options?: QiDropTableOptions): Promise<void>
Drop a table from database
Parameters
- tableName: TableOrModel
  Table name to drop
- Optionaloptions: QiDropTableOptions
  Query options
Returns Promise<void>
Inherited from AbstractQueryInterfaceTypeScript.dropTable
- Defined in packages/core/src/abstract-dialect/query-interface-typescript.ts:239

dropTrigger

dropTrigger(
    tableName: TableName,
    triggerName: string,
    options?: QiOptionsWithReplacements,
): Promise<void>
Postgres only. Drops the specified trigger.
Parameters
- tableName: TableName
- triggerName: string
- Optionaloptions: QiOptionsWithReplacements
Returns Promise<void>
- Defined in packages/core/src/abstract-dialect/query-interface.d.ts:440

fetchDatabaseVersion

fetchDatabaseVersion(options?: FetchDatabaseVersionOptions): Promise<string>
Returns the database version.
Parameters
- Optionaloptions: FetchDatabaseVersionOptions
  Query Options
Returns Promise<string>
Inherited from AbstractQueryInterfaceTypeScript.fetchDatabaseVersion
- Defined in packages/core/src/abstract-dialect/query-interface-typescript.ts:128

getForeignKeyReferencesForTable

getForeignKeyReferencesForTable(
_tableName: TableOrModel,
_options?: QueryRawOptions,
): Error
Get foreign key references details for the table
Parameters
- _tableName: TableOrModel
- Optional_options: QueryRawOptions
Returns Error
Deprecated
Use showConstraints instead.
Inherited from AbstractQueryInterfaceTypeScript.getForeignKeyReferencesForTable
- Defined in packages/core/src/abstract-dialect/query-interface-typescript.ts:687

getForeignKeysForTables

getForeignKeysForTables(
_tableNames: TableOrModel[],
_options?: QueryRawOptions,
): Error
Returns all foreign key constraints of requested tables
Parameters
- _tableNames: TableOrModel[]
- Optional_options: QueryRawOptions
Returns Error
Deprecated
Use showConstraints instead.
Inherited from AbstractQueryInterfaceTypeScript.getForeignKeysForTables
- Defined in packages/core/src/abstract-dialect/query-interface-typescript.ts:676

increment

increment<M extends Model<any, any>>(
    model: ModelStatic<M>,
    tableName: TableName,
    where: WhereOptions<Attributes<M>>,
    incrementAmountsByField: object,
    extraAttributesToBeUpdated: object,
    options?: QiArithmeticOptions,
): Promise<object>
Increments a row value
Type Parameters
- M extends Model<any, any>
Parameters
- model: ModelStatic<M>
- tableName: TableName
- where: WhereOptions<Attributes<M>>
- incrementAmountsByField: object
- extraAttributesToBeUpdated: object
- Optionaloptions: QiArithmeticOptions
Returns Promise<object>
- Defined in packages/core/src/abstract-dialect/query-interface.d.ts:389

insert

insert(
    instance: null | Model<any, any>,
    tableName: TableName,
    values: object,
    options?: QiInsertOptions,
): Promise<object>
Inserts a new record
Parameters
- instance: null | Model<any, any>
- tableName: TableName
- values: object
- Optionaloptions: QiInsertOptions
Returns Promise<object>
- Defined in packages/core/src/abstract-dialect/query-interface.d.ts:327

listDatabases

listDatabases(options?: ListDatabasesOptions): Promise<DatabaseDescription[]>
Lists all available databases
Parameters
- Optionaloptions: ListDatabasesOptions
Returns Promise<DatabaseDescription[]>
Inherited from AbstractQueryInterfaceTypeScript.listDatabases
- Defined in packages/core/src/abstract-dialect/query-interface-typescript.ts:114

listSchemas

listSchemas(options?: QiListSchemasOptions): Promise<string[]>
List defined schemas

Note: this is a schema in the postgres sense of the word, not a database table. In mysql and mariadb, this will show all databases.
Parameters
- Optionaloptions: QiListSchemasOptions
Returns Promise<string[]>
list of schemas
Inherited from AbstractQueryInterfaceTypeScript.listSchemas
- Defined in packages/core/src/abstract-dialect/query-interface-typescript.ts:210

listTables

listTables(options?: QiListTablesOptions): Promise<TableNameWithSchema[]>
List tables
Parameters
- Optionaloptions: QiListTablesOptions
Returns Promise<TableNameWithSchema[]>
Inherited from AbstractQueryInterfaceTypeScript.listTables
- Defined in packages/core/src/abstract-dialect/query-interface-typescript.ts:286

nameIndexes

nameIndexes(indexes: string[], rawTablename: string): Promise<void>
Put a name to an index
Parameters
- indexes: string[]
- rawTablename: string
Returns Promise<void>
- Defined in packages/core/src/abstract-dialect/query-interface.d.ts:322

quoteIdentifier

quoteIdentifier(identifier: string, force?: boolean): string
Escape an identifier (e.g. a table or attribute name). If force is true, the identifier will be quoted even if the quoteIdentifiers option is false.
Parameters
- identifier: string
- Optionalforce: boolean
Returns string
- Defined in packages/core/src/abstract-dialect/query-interface.d.ts:492

quoteIdentifiers

quoteIdentifiers(identifiers: string): string
Split an identifier into .-separated tokens and quote each part.
Parameters
- identifiers: string
Returns string
- Defined in packages/core/src/abstract-dialect/query-interface.d.ts:497

rawSelect

rawSelect(
    tableName: TableName,
    options: QiSelectOptions,
    attributeSelector: string,
    model?: ModelStatic,
): Promise<string[]>
Selects raw without parsing the string into an object
Parameters
- tableName: TableName
- options: QiSelectOptions
- attributeSelector: string
- Optionalmodel: ModelStatic
Returns Promise<string[]>
- Defined in packages/core/src/abstract-dialect/query-interface.d.ts:413

removeColumn

removeColumn(
    tableName: TableOrModel,
    columnName: string,
    options?: RemoveColumnOptions,
): Promise<void>
Removes a column from a table
Parameters
- tableName: TableOrModel
- columnName: string
- Optionaloptions: RemoveColumnOptions
Returns Promise<void>
Inherited from AbstractQueryInterfaceTypeScript.removeColumn
- Defined in packages/core/src/abstract-dialect/query-interface-typescript.ts:442

removeConstraint

removeConstraint(
    tableName: TableOrModel,
    constraintName: string,
    options?: RemoveConstraintOptions,
): Promise<void>
Remove a constraint from a table
Parameters
- tableName: TableOrModel
  Table name to drop constraint from
- constraintName: string
  Constraint name
- Optionaloptions: RemoveConstraintOptions
  Query options
Returns Promise<void>
Inherited from AbstractQueryInterfaceTypeScript.removeConstraint
- Defined in packages/core/src/abstract-dialect/query-interface-typescript.ts:578

removeIndex

removeIndex(
    tableName: TableName,
    indexName: string,
    options?: QueryInterfaceRemoveIndexOptions,
): Promise<void>
Removes an index of a table
Parameters
- tableName: TableName
- indexName: string
- Optionaloptions: QueryInterfaceRemoveIndexOptions
Returns Promise<void>
- Defined in packages/core/src/abstract-dialect/query-interface.d.ts:303
removeIndex(
    tableName: TableName,
    attributes: string[],
    options?: QueryInterfaceRemoveIndexOptions,
): Promise<void>
Removes an index of a table
Parameters
- tableName: TableName
- attributes: string[]
- Optionaloptions: QueryInterfaceRemoveIndexOptions
Returns Promise<void>
- Defined in packages/core/src/abstract-dialect/query-interface.d.ts:308

renameColumn

renameColumn(
    tableName: TableName,
    attrNameBefore: string,
    attrNameAfter: string,
    options?: QiOptionsWithReplacements,
): Promise<void>
Renames a column
Parameters
- tableName: TableName
- attrNameBefore: string
- attrNameAfter: string
- Optionaloptions: QiOptionsWithReplacements
Returns Promise<void>
- Defined in packages/core/src/abstract-dialect/query-interface.d.ts:278

renameFunction

renameFunction(
    oldFunctionName: string,
    params: FunctionParam[],
    newFunctionName: string,
    options?: QiOptionsWithReplacements,
): Promise<void>
Postgres only. Rename a function
Parameters
- oldFunctionName: string
- params: FunctionParam[]
- newFunctionName: string
- Optionaloptions: QiOptionsWithReplacements
Returns Promise<void>
- Defined in packages/core/src/abstract-dialect/query-interface.d.ts:481

renameTable

renameTable(
    beforeTableName: TableOrModel,
    afterTableName: TableOrModel,
    options?: RenameTableOptions,
): Promise<void>
Rename a table
Parameters
- beforeTableName: TableOrModel
- afterTableName: TableOrModel
- Optionaloptions: RenameTableOptions
Returns Promise<void>
Inherited from AbstractQueryInterfaceTypeScript.renameTable
- Defined in packages/core/src/abstract-dialect/query-interface-typescript.ts:315

renameTrigger

renameTrigger(
    tableName: TableName,
    oldTriggerName: string,
    newTriggerName: string,
    options?: QiOptionsWithReplacements,
): Promise<void>
Postgres only. Renames a trigger
Parameters
- tableName: TableName
- oldTriggerName: string
- newTriggerName: string
- Optionaloptions: QiOptionsWithReplacements
Returns Promise<void>
- Defined in packages/core/src/abstract-dialect/query-interface.d.ts:449

select

select(
    model: null | ModelStatic,
    tableName: TableName,
    options?: QiSelectOptions,
): Promise<object[]>
Returns selected rows
Parameters
- model: null | ModelStatic
- tableName: TableName
- Optionaloptions: QiSelectOptions
Returns Promise<object[]>
- Defined in packages/core/src/abstract-dialect/query-interface.d.ts:380

showAllSchemas

showAllSchemas(options?: QiListSchemasOptions): Promise<string[]>
Show all defined schemas
Parameters
- Optionaloptions: QiListSchemasOptions
Returns Promise<string[]>
Deprecated
Use listSchemas instead.
Inherited from AbstractQueryInterfaceTypeScript.showAllSchemas
- Defined in packages/core/src/abstract-dialect/query-interface-typescript.ts:227

showAllTables

showAllTables(options?: QiListTablesOptions): Promise<TableNameWithSchema[]>
Show all tables
Parameters
- Optionaloptions: QiListTablesOptions
Returns Promise<TableNameWithSchema[]>
Deprecated
Use listTables instead.
Inherited from AbstractQueryInterfaceTypeScript.showAllTables
- Defined in packages/core/src/abstract-dialect/query-interface-typescript.ts:302

showConstraints

showConstraints(
tableName: TableOrModel,
options?: ShowConstraintsOptions,
): Promise<ConstraintDescription[]>
Parameters
- tableName: TableOrModel
- Optionaloptions: ShowConstraintsOptions
Returns Promise<ConstraintDescription[]>
Inherited from AbstractQueryInterfaceTypeScript.showConstraints
- Defined in packages/core/src/abstract-dialect/query-interface-typescript.ts:588

showIndex

showIndex(
tableName: TableOrModel,
options?: QueryRawOptions,
): Promise<IndexDescription[]>
Shows the index of a table
Parameters
- tableName: TableOrModel
- Optionaloptions: QueryRawOptions
Returns Promise<IndexDescription[]>
- Defined in packages/core/src/abstract-dialect/query-interface.d.ts:317

tableExists

tableExists(
tableName: TableOrModel,
options?: QueryRawOptions,
): Promise<boolean>
Returns a promise that will resolve to true if the table or model exists in the database, false otherwise.
Parameters
- tableName: TableOrModel
  The name of the table or model
- Optionaloptions: QueryRawOptions
  Query options
Returns Promise<boolean>
Inherited from AbstractQueryInterfaceTypeScript.tableExists
- Defined in packages/core/src/abstract-dialect/query-interface-typescript.ts:331

truncate

truncate(
tableName: TableOrModel,
options?: QiTruncateTableOptions,
): Promise<void>
Truncates a table
Parameters
- tableName: TableOrModel
- Optionaloptions: QiTruncateTableOptions
Returns Promise<void>
Inherited from AbstractQueryInterfaceTypeScript.truncate
- Defined in packages/core/src/abstract-dialect/query-interface-typescript.ts:425

unsafeToggleForeignKeyChecks

unsafeToggleForeignKeyChecks(
enable: boolean,
options?: QueryRawOptions,
): Promise<void>
Toggles foreign key checks. Don't forget to turn them back on, use withoutForeignKeyChecks to do this automatically.
Parameters
- enable: boolean
- Optionaloptions: QueryRawOptions
Returns Promise<void>
Inherited from AbstractQueryInterfaceTypeScript.unsafeToggleForeignKeyChecks
- Defined in packages/core/src/abstract-dialect/query-interface-typescript.ts:767

update

update<M extends Model<any, any>>(
    instance: M,
    tableName: TableName,
    values: object,
    where: WhereOptions<Attributes<M>>,
    options?: QiUpdateOptions,
): Promise<object>
Updates a row
Type Parameters
- M extends Model<any, any>
Parameters
- instance: M
- tableName: TableName
- values: object
- where: WhereOptions<Attributes<M>>
- Optionaloptions: QiUpdateOptions
Returns Promise<object>
- Defined in packages/core/src/abstract-dialect/query-interface.d.ts:358

upsert

upsert<M extends Model<any, any>>(
    tableName: TableName,
    insertValues: object,
    updateValues: object,
    where: object,
    options?: QiUpsertOptions<M>,
): Promise<object>
Inserts or Updates a record in the database
Type Parameters
- M extends Model<any, any>
Parameters
- tableName: TableName
- insertValues: object
- updateValues: object
- where: object
- Optionaloptions: QiUpsertOptions<M>
Returns Promise<object>
- Defined in packages/core/src/abstract-dialect/query-interface.d.ts:337

withoutForeignKeyChecks

withoutForeignKeyChecks<T>(cb: WithoutForeignKeyChecksCallback<T>): Promise<T>
Disables foreign key checks for the duration of the callback. The foreign key checks are only disabled for the current connection. To specify the connection, you can either use the "connection" or the "transaction" option. If you do not specify a connection, this method will reserve a connection for the duration of the callback, and release it afterwards. You will receive the connection or transaction as the first argument of the callback. You must use this connection to execute queries
Type Parameters
- T
Parameters
- cb: WithoutForeignKeyChecksCallback<T>
Returns Promise<T>
Example
```
await this.queryInterface.withoutForeignKeyChecks(options, async connection => {
  const truncateOptions = { ...options, connection };

  for (const model of models) {
    await model.truncate(truncateOptions);
  }
});
```
Inherited from AbstractQueryInterfaceTypeScript.withoutForeignKeyChecks
- Defined in packages/core/src/abstract-dialect/query-interface-typescript.ts:714
withoutForeignKeyChecks<T>(
options: QueryRawOptions,
cb: WithoutForeignKeyChecksCallback<T>,
): Promise<T>
Disables foreign key checks for the duration of the callback. The foreign key checks are only disabled for the current connection. To specify the connection, you can either use the "connection" or the "transaction" option. If you do not specify a connection, this method will reserve a connection for the duration of the callback, and release it afterwards. You will receive the connection or transaction as the first argument of the callback. You must use this connection to execute queries
Type Parameters
- T
Parameters
- options: QueryRawOptions
- cb: WithoutForeignKeyChecksCallback<T>
Returns Promise<T>
Example
```
await this.queryInterface.withoutForeignKeyChecks(options, async connection => {
  const truncateOptions = { ...options, connection };

  for (const model of models) {
    await model.truncate(truncateOptions);
  }
});
```
Inherited from AbstractQueryInterfaceTypeScript.withoutForeignKeyChecks
- Defined in packages/core/src/abstract-dialect/query-interface-typescript.ts:715

Class AbstractQueryInterface<Dialect>

Type Parameters

Hierarchy (View Summary)

Index

Constructors

Properties

Accessors

Methods

Constructors

constructor

Type Parameters

Parameters

Returns AbstractQueryInterface<Dialect>

Properties

Readonlydialect

Accessors

queryGenerator

Returns Dialect["queryGenerator"]

sequelize

Returns Sequelize<Dialect>

Methods

_commitTransaction

Parameters

Returns Promise<void>

_createSavepoint

Parameters

Returns Promise<void>

_rollbackSavepoint

Parameters

Returns Promise<void>

_rollbackTransaction

Parameters

Returns Promise<void>

_setIsolationLevel

Parameters

Returns Promise<void>

_startTransaction

Parameters

Returns Promise<void>

addColumn

Parameters

Returns Promise<void>

addConstraint

Parameters

Returns Promise<void>

Example: UNIQUE

Example: CHECK

Example: Default - MSSQL only

Example: Primary Key

Example: Composite Primary Key

Example: Foreign Key

Example: Composite Foreign Key

addIndex

Parameters

Returns Promise<void>

Parameters

Optionalbenchmark?: boolean

Optionalbind?: BindOrReplacements

Optionalconcurrently?: boolean

Default

Optionalconnection?: null | AbstractConnection

OptionalfieldMap?: FieldMap

fields: (string | Fn | Literal | IndexField)[]

Optionalinclude?: Literal | (string | Literal)[]

Optionalinstance?: Model<any, any>

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

OptionalmapToModel?: boolean

Optionalmsg?: string

Optionalname?: string

Optionalnest?: boolean

Default

Optionaloperator?: string

Optionalparser?: null | string

Optionalplain?: boolean

Optionalprefix?: string

Optionalraw?: boolean

Optionalreplacements?: { [key: string]: unknown }

Optionalretry?: Options

OptionalsupportsSearchPath?: boolean

Optionaltransaction?: null | Transaction

`Readonly`dialect

`Optional`benchmark?: boolean

`Optional`bind?: BindOrReplacements

`Optional`concurrently?: boolean

`Optional`connection?: null | AbstractConnection

`Optional`fieldMap?: FieldMap

`Optional`include?: Literal | (string | Literal)[]

`Optional`instance?: Model<any, any>

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

`Optional`mapToModel?: boolean

`Optional`msg?: string

`Optional`name?: string

`Optional`nest?: boolean

`Optional`operator?: string

`Optional`parser?: null | string

`Optional`plain?: boolean

`Optional`prefix?: string

`Optional`raw?: boolean

`Optional`replacements?: { [key: string]: unknown }

`Optional`retry?: Options

`Optional`supportsSearchPath?: boolean

`Optional`transaction?: null | Transaction

`Optional`type?: IndexType

`Optional`unique?: boolean

`Optional`useMaster?: boolean

`Optional`using?: string

`Optional`where?: WhereOptions