Using non-standard database that is compatible with PostgreSQL wire protocol (such as CockroachDB)

Specify PostgreSQL version that database you are using is compatible with protocol-wise using version option, e. g.:

const knex = require('knex')({
  client: 'pg',
  version: '7.2',
  connection: {
    host: '',
    user: 'your_database_user',
    password: 'your_database_password',
    database: 'myapp_test'

Note that value of version option should be not the version of the database that you are using, but version of PostgreSQL that most closely matches functionality of the database that you are using. If not provided by database vendor, try using '7.2' as a baseline and keep increasing (within the range of existing PostgreSQL versions) until it starts (or stops) working.

There are also known incompatibilities with migrations for databases that do not support select for update. See for a workaround.

Connecting to MSSQL on Azure SQL Database

{encrypt: true} should be included in options branch of connection configuration:

  client : 'mssql',
  connection: {
    database: 'mydatabase',
    server: '',
    user: 'myuser',
    password: 'mypass',
    port: 1433,
    connectionTimeout: 30000,
    options: {
      encrypt: true

See all of node-mssql's connection options

Adding a full-text index for PostgreSQL

exports.up = (knex) => {
  return knex.schema.createTable('foo', (table) => {
    table.specificType('fulltext', 'tsvector');
    table.index('fulltext', null, 'gin');

DB access using SQLite and SQLCipher

After you build the SQLCipher source and the npm SQLite3 package, and encrypt your DB (look elsewhere for these things), then anytime you open your database, you need to provide your encryption key using the SQL statement:

PRAGMA KEY = 'secret'

This PRAGMA is more completely documented in the SQLCipher site. When working with Knex this is best done when opening the DB, via the following:

const myDBConfig = {
  client: "sqlite3",
  connection: {
    filename: "myEncryptedSQLiteDbFile.db"
  pool: {
    afterCreate: function(conn, done) {"PRAGMA KEY = 'secret'");
const knex = require('knex')(myDBConfig);

Of course embedding the key value in your code is a poor security practice. Instead, retrieve the 'secret' from elsewhere.

The key Knex thing to note here is the "afterCreate" function. This is documented in the site, but is not in the Table of Contents at this time, so do a browser find when on the site to get to it. It allows auto-updating DB settings when creating any new pool connections (of which there will only ever be one per file for Knex-SQLite).

If you don't use the "afterCreate" configuration, then you will need to run a knex.raw statement with each and every SQL you execute, something like as follows:

return knex.raw("PRAGMA KEY = 'secret'")
  .then(() => knex('some_table')
    .on('query-error', function(ex, obj) {
        "KNEX select from some_table ERR ex:", 

Maintaining changelog for seeds (version >= 0.16.0-next1)

In case you would like to use Knex.js changelog functionality to ensure your environments are only seeded once, but don't want to mix seed files with migration files, you can specify multiple directories as a source for your migrations:

await knex.migrate.latest({
    directory: [
    sortDirsSeparately: true,
    tableName: 'orders_migrations',
    schemaName: 'orders',  

Using explicit transaction management together with async code

await knex.transaction(trx => {
  async function stuff() {
    trx.rollback(new Error('Foo'));
    .then(() => {
      // do something

Or alternatively:

try {
  await knex.transaction(trx => {
    async function stuff() {
      trx.rollback(new Error('always explicit rollback this time'));
  // transaction was committed
  } catch (err) {
    // transaction was rolled back 

(note that promise for knex.transaction resolves after transaction is rolled back or committed)

Using parentheses with AND operator

In order to generate query along the lines of

SELECT "firstName", "lastName", "status"
FROM "userInfo" 
WHERE "status" = 'active'
AND ("firstName" ILIKE '%Ali%' OR "lastName" ILIKE '%Ali%');

you need to use following approach:

  .where('status', status.uuid)
  .andWhere((qB) => qB
    .where('firstName', 'ilike', `%${q}%`)
    .orWhere('lastName', 'ilike', `%${q}%`)

Calling an oracle stored procedure with bindout variables

How to call and retrieve output from an oracle stored procedure

const oracle = require('oracledb');
const bindVars = {
  input_var1: 6,
  input_var2: 7,
  output_var: {
    dir: oracle.BIND_OUT
  output_message: {
    dir: oracle.BIND_OUT

const sp = 'BEGIN MULTIPLY_STORED_PROCEDURE(:input_var1, :input_var2, :output_var, :output_message); END;';
const results = await knex.raw(sp, bindVars);
console.log(results[0]); // 42
console.log(results[1]); // 6 * 7 is the answer to life

Node instance doesn't stop after using knex

Make sure to close knex instance after execution to avoid Node process hanging due to open connections:

async function migrate() {
  try {
    await knex.migrate.latest({/**config**/})
  } catch (e) {
  } finally {
    try {
    } catch (e) {
      // ignore


Manually Closing Streams

When using Knex's stream interface, you can typically just pipe the return stream to any writable stream. However, with HTTPIncomingMessage, you'll need to take special care to handle aborted requests.

An HTTPIncomingMessage object is typically called request. This is the first argument in 'request' events emitted on http.Server instances. Express's req implements a compatible interface and Hapi exposes this object on its request objects as request.raw.req.

You need to explicitly handle the case where an HTTPIncomingMessage is closed prematurely when streaming from a database with Knex. The easiest way to cause this is:

  1. Visit an endpoint that takes several seconds to fully transmit a response
  2. Close the browser window immediately after beginning the request

When this happens while you are streaming a query to a client, you need to manually tell Knex that it can release the database connection in use back to the connection pool.

server.on('request', function (request, response) {
  const stream ='*').from('items').stream();
  request.on('close', stream.end.bind(stream));