Class CreateQueryInterface

Create a new QueryInterface instance

Get the dialect instance

Create a new table

Create a partitioned table (PostgreSQL 10+)

Create a partition for an existing partitioned table (PostgreSQL 10+)

Attach a partition to a partitioned table (PostgreSQL 11+)

Detach a partition from a partitioned table (PostgreSQL 11+)

Drop a partition (PostgreSQL 10+)

Drop a table

Drop all tables (dialect-specific)

Rename a table

Add a column to a table

Remove a column from a table

Change a column definition

Rename a column

Add an index to a table

Remove an index from a table

Show all indexes for a table

Add a constraint to a table

Remove a constraint from a table

Check if an index exists on a table

Bulk insert records

Bulk update records

Bulk delete records

Describe a table (get column information)

Show all tables in the database

Check if a table exists

Get all table names with schema (for PostgreSQL, MySQL, etc.)

Get foreign keys for a table

Get constraints for a table

Create a database (for databases that support it)

Drop a database (for databases that support it)

Create a database view.

Define the view the same way you would write the query it saves — a view is a saved query, so definition takes the findAll() options and the dialect compiles them:

await qi.createView('customer_info', {
  from: Customer,
  attributes: ['firstName', 'lastName', 'email'],
  where: { country: 'USA' },
});
Copy

Drop a database view

Show all views in the database

Check if a view exists

Create a materialized view.

Takes the same structured definition as createView — pass query options rather than a SELECT string:

await qi.createMaterializedView({
  name: 'order_totals',
  definition: {
    from: Order,
    attributes: ['userId', [fn('COUNT', col('id')), 'orderCount']],
    group: 'userId',
  },
});
Copy

Refresh a materialized view

Drop a materialized view

Check if a materialized view exists

Show all materialized views in the database

Create a sequence.

Drop a sequence.

Create a trigger.

On PostgreSQL this also creates the backing trigger function, which the database requires and which a hand-written CREATE TRIGGER easily forgets.

Drop a trigger.

Enable row-level security on a table (PostgreSQL family).

Disable row-level security on a table (PostgreSQL family).

Create a row-level security policy.

Register a function written in a language other than SQL.

Two shapes, matching what databases offer. Compiled — you wrote C, built a shared library, and want the database to call into it:

// MySQL: the library lives in the server's plugin_dir
await qi.createExternalFunction({
  name: 'levenshtein',
  language: 'c',
  returns: 'INTEGER',
  library: 'my_udf.so',
});

// PostgreSQL: object file plus the exported symbol
await qi.createExternalFunction({
  name: 'levenshtein',
  language: 'c',
  returns: 'integer',
  params: [{ name: 'a', type: 'text' }, { name: 'b', type: 'text' }],
  library: '$libdir/my_udf',
  symbol: 'pg_levenshtein',
  strict: true,
  volatility: 'IMMUTABLE',
});
Copy

Or interpreted — the source is stored in the database and run by a procedural-language handler:

await qi.createExternalFunction({
  name: 'slugify',
  language: 'plpython3u',
  returns: 'text',
  params: [{ name: 'value', type: 'text' }],
  source: 'import re\nreturn re.sub(r"[^a-z0-9]+", "-", value.lower()).strip("-")',
});
Copy

source is code in that language — it is stored verbatim and never parsed as SQL. MySQL supports only the compiled form.

Drop an external function.

PostgreSQL identifies overloads by argument types, so pass the same params used to create it when more than one overload exists.

Drop a row-level security policy.

Create a full-text index.

Emits a GIN index over to_tsvector on PostgreSQL, a FULLTEXT index on MySQL/MariaDB, and an FTS5 virtual table on SQLite.

Execute a raw query

Quote an identifier

Escape a value