1. module knex
   1. function knex.Client ()
   2. function knex.formatter (client)
   3. function knex.functionhelper (client)
   4. function knex.migrate (knex)
   5. function knex.raw (sql, bindings)
   6. function knex.runner (client, builder)
   7. function knex.seed (knex)
   8. function knex.transaction (client, container, config, outerTx)
   9. object knex.Client.prototype
   10. object knex.formatter.prototype
   11. object knex.functionhelper.prototype
   12. object knex.helpers
   13. object knex.migrate.prototype
   14. object knex.raw.prototype
   15. object knex.runner.prototype
   16. object knex.seed.prototype
   17. object knex.transaction.prototype
2. module knex.Client
   1. function knex.Client ()
   2. function knex.Client.super_ ()
3. module knex.Client.prototype
   1. boolean knex.Client.prototype.canCancelQuery
   2. function knex.Client.prototype._escapeBinding (val)
   3. function knex.Client.prototype._formatQuery (sql, bindings, timeZone)
   4. function knex.Client.prototype.acquireConnection ()
   5. function knex.Client.prototype.assertCanCancelQuery ()
   6. function knex.Client.prototype.cancelQuery ()
   7. function knex.Client.prototype.columnBuilder (tableBuilder, type, args)
   8. function knex.Client.prototype.columnCompiler (tableBuilder, columnBuilder)
   9. function knex.Client.prototype.database ()
   10. function knex.Client.prototype.destroy (callback)
   11. function knex.Client.prototype.formatter ()
   12. function knex.Client.prototype.initializeDriver ()
   13. function knex.Client.prototype.initializePool (config)
   14. function knex.Client.prototype.poolDefaults (poolConfig)
   15. function knex.Client.prototype.prepBindings (bindings)
   16. function knex.Client.prototype.query (connection, obj)
   17. function knex.Client.prototype.queryBuilder ()
   18. function knex.Client.prototype.queryCompiler (builder)
   19. function knex.Client.prototype.raw ()
   20. function knex.Client.prototype.releaseConnection (connection)
   21. function knex.Client.prototype.runner (connection)
   22. function knex.Client.prototype.schemaBuilder ()
   23. function knex.Client.prototype.schemaCompiler (builder)
   24. function knex.Client.prototype.stream (connection, obj, _stream, options)
   25. function knex.Client.prototype.tableBuilder (type, tableName, fn)
   26. function knex.Client.prototype.tableCompiler (tableBuilder)
   27. function knex.Client.prototype.toString ()
   28. function knex.Client.prototype.transaction (container, config, outerTx)
   29. function knex.Client.prototype.validateConnection (connection)
   30. function knex.Client.prototype.wrapIdentifier (value)
4. module knex.formatter
   1. function knex.formatter (client)
5. module knex.formatter.prototype
   1. function knex.formatter.prototype._wrapString (value)
   2. function knex.formatter.prototype.alias (first, second)
   3. function knex.formatter.prototype.columnize (target)
   4. function knex.formatter.prototype.compileCallback (callback, method)
   5. function knex.formatter.prototype.direction (value)
   6. function knex.formatter.prototype.operator (value)
   7. function knex.formatter.prototype.outputQuery (compiled, isParameter)
   8. function knex.formatter.prototype.parameter (value)
   9. function knex.formatter.prototype.parameterize (values, notSetValue)
   10. function knex.formatter.prototype.rawOrFn (value, method)
   11. function knex.formatter.prototype.unwrapRaw (value, isParameter)
   12. function knex.formatter.prototype.wrap (value)
   13. function knex.formatter.prototype.wrapAsIdentifier (value)
6. module knex.functionhelper
   1. function knex.functionhelper (client)
7. module knex.functionhelper.prototype
   1. function knex.functionhelper.prototype.now ()
8. module knex.helpers
   1. boolean knex.helpers.__esModule
   2. function knex.helpers.containsUndefined (mixed)
   3. function knex.helpers.debugLog (msg)
   4. function knex.helpers.deprecate (method, alternate)
   5. function knex.helpers.error (msg)
   6. function knex.helpers.exit (msg)
   7. function knex.helpers.normalizeArr ()
   8. function knex.helpers.skim (data)
   9. function knex.helpers.warn (msg)
9. module knex.migrate
   1. function knex.migrate (knex)
10. module knex.migrate.prototype
    1. function knex.migrate.prototype._absoluteConfigDir ()
    2. function knex.migrate.prototype._createMigrationLockTable (tableName)
    3. function knex.migrate.prototype._createMigrationTable (tableName)
    4. function knex.migrate.prototype._ensureFolder ()
    5. function knex.migrate.prototype._ensureTable ()
    6. function knex.migrate.prototype._freeLock ()
    7. function knex.migrate.prototype._generateStubTemplate ()
    8. function knex.migrate.prototype._getLastBatch ()
    9. function knex.migrate.prototype._getLock ()
    10. function knex.migrate.prototype._getLockTableName ()
    11. function knex.migrate.prototype._isLocked (trx)
    12. function knex.migrate.prototype._latestBatchNumber ()
    13. function knex.migrate.prototype._listAll (config)
    14. function knex.migrate.prototype._listCompleted ()
    15. function knex.migrate.prototype._lockMigrations (trx)
    16. function knex.migrate.prototype._migrationData ()
    17. function knex.migrate.prototype._runBatch (migrations, direction)
    18. function knex.migrate.prototype._transaction (migration, direction, name)
    19. function knex.migrate.prototype._useTransaction (migration, allTransactionsDisabled)
    20. function knex.migrate.prototype._validateMigrationStructure (name)
    21. function knex.migrate.prototype._waterfallBatch (batchNo, migrations, direction)
    22. function knex.migrate.prototype._writeNewMigration (name, tmpl)
    23. function knex.migrate.prototype.currentVersion (config)
    24. function knex.migrate.prototype.forceFreeMigrationsLock (config)
    25. function knex.migrate.prototype.latest (config)
    26. function knex.migrate.prototype.make (name, config)
    27. function knex.migrate.prototype.rollback (config)
    28. function knex.migrate.prototype.setConfig (config)
    29. function knex.migrate.prototype.status (config)
11. module knex.raw
    1. function knex.raw ()
    2. function knex.raw.super_ ()
12. module knex.raw.prototype
    1. function knex.raw.prototype.asCallback ()
    2. function knex.raw.prototype.bind ()
    3. function knex.raw.prototype.catch ()
    4. function knex.raw.prototype.connection (connection)
    5. function knex.raw.prototype.debug (enabled)
    6. function knex.raw.prototype.delay ()
    7. function knex.raw.prototype.ensure ()
    8. function knex.raw.prototype.finally ()
    9. function knex.raw.prototype.get ()
    10. function knex.raw.prototype.map ()
    11. function knex.raw.prototype.mapSeries ()
    12. function knex.raw.prototype.options (opts)
    13. function knex.raw.prototype.pipe (writable, options)
    14. function knex.raw.prototype.reduce ()
    15. function knex.raw.prototype.reflect ()
    16. function knex.raw.prototype.return ()
    17. function knex.raw.prototype.set (sql, bindings)
    18. function knex.raw.prototype.spread ()
    19. function knex.raw.prototype.stream (options)
    20. function knex.raw.prototype.tap ()
    21. function knex.raw.prototype.then ()
    22. function knex.raw.prototype.thenReturn ()
    23. function knex.raw.prototype.timeout (ms)
    24. function knex.raw.prototype.toQuery (tz)
    25. function knex.raw.prototype.toSQL (method, tz)
    26. function knex.raw.prototype.toString ()
    27. function knex.raw.prototype.transacting (t)
    28. function knex.raw.prototype.wrap (before, after)
    29. function knex.raw.prototype.yield ()
13. module knex.runner
    1. function knex.runner (client, builder)
14. module knex.runner.prototype
    1. function knex.runner.prototype.ensureConnection ()
    2. function knex.runner.prototype.pipe (writable, options)
    3. function knex.runner.prototype.query ()
    4. function knex.runner.prototype.queryArray (queries)
    5. function knex.runner.prototype.run ()
    6. function knex.runner.prototype.stream (options, handler)
15. module knex.seed
    1. function knex.seed (knex)
16. module knex.seed.prototype
    1. function knex.seed.prototype._absoluteConfigDir ()
    2. function knex.seed.prototype._ensureFolder ()
    3. function knex.seed.prototype._generateStubTemplate ()
    4. function knex.seed.prototype._listAll ()
    5. function knex.seed.prototype._runSeeds (seeds)
    6. function knex.seed.prototype._seedData ()
    7. function knex.seed.prototype._validateSeedStructure (name)
    8. function knex.seed.prototype._waterfallBatch (seeds)
    9. function knex.seed.prototype._writeNewSeed (name)
    10. function knex.seed.prototype.make (name, config)
    11. function knex.seed.prototype.run ()
    12. function knex.seed.prototype.setConfig (config)
17. module knex.transaction
    1. function knex.transaction (client, container, config, outerTx)
18. module knex.transaction.prototype
    1. function knex.transaction.prototype.acquireConnection (client, config, txid)
    2. function knex.transaction.prototype.asCallback ()
    3. function knex.transaction.prototype.begin (conn)
    4. function knex.transaction.prototype.bind ()
    5. function knex.transaction.prototype.catch ()
    6. function knex.transaction.prototype.commit (conn, value)
    7. function knex.transaction.prototype.debug (enabled)
    8. function knex.transaction.prototype.delay ()
    9. function knex.transaction.prototype.ensure ()
    10. function knex.transaction.prototype.exec ()
    11. function knex.transaction.prototype.finally ()
    12. function knex.transaction.prototype.get ()
    13. function knex.transaction.prototype.isCompleted ()
    14. function knex.transaction.prototype.map ()
    15. function knex.transaction.prototype.mapSeries ()
    16. function knex.transaction.prototype.query (conn, sql, status, value)
    17. function knex.transaction.prototype.reduce ()
    18. function knex.transaction.prototype.reflect ()
    19. function knex.transaction.prototype.release (conn, value)
    20. function knex.transaction.prototype.return ()
    21. function knex.transaction.prototype.rollback (conn, error)
    22. function knex.transaction.prototype.rollbackTo (conn, error)
    23. function knex.transaction.prototype.savepoint (conn)
    24. function knex.transaction.prototype.spread ()
    25. function knex.transaction.prototype.tap ()
    26. function knex.transaction.prototype.then ()
    27. function knex.transaction.prototype.thenReturn ()
    28. function knex.transaction.prototype.yield ()

module knex

function knex.Client ()

• description and source-code

  function Client() {
    var config = arguments.length <= 0 || arguments[0] === undefined ? {} : arguments[0];
  
    this.config = config;
  
    //Client is a required field, so throw error if it's not supplied.
    //If 'this.dialect' is set, then this is a 'super()' call, in which case
    //'client' does not have to be set as it's already assigned on the client prototype.
    if (!this.config.client && !this.dialect) {
      throw new Error('knex: Required configuration option \'client\' is missing.');
    }
  
    this.connectionSettings = (0, _cloneDeep3.default)(config.connection || {});
    if (this.driverName && config.connection) {
      this.initializeDriver();
      if (!config.pool || config.pool && config.pool.max !== 0) {
        this.__cid = clientId();
        this.initializePool(config);
      }
    }
    this.valueForUndefined = this.raw('DEFAULT');
    if (config.useNullAsDefault) {
      this.valueForUndefined = null;
    }
  }

• example usage

  n/a

function knex.formatter (client)

• description and source-code

  function Formatter(client) {
    (0, _classCallCheck3.default)(this, Formatter);
  
    this.client = client;
    this.bindings = [];
  }

• example usage

  ...
  return this.toQuery();
    },
  
  
    // Returns the raw sql for the query.
    toSQL: function toSQL(method, tz) {
  var obj = void 0;
  var formatter = this.client.formatter();
  
  if (Array.isArray(this.bindings)) {
    obj = replaceRawArrBindings(this, formatter);
  } else if (this.bindings && (0, _isPlainObject3.default)(this.bindings)) {
    obj = replaceKeyBindings(this, formatter);
  } else {
    obj = {
  ...

function knex.functionhelper (client)

• description and source-code

  function FunctionHelper(client) {
    this.client = client;
  }

• example usage

  n/a

function knex.migrate (knex)

• description and source-code

  function Migrator(knex) {
    (0, _classCallCheck3.default)(this, Migrator);
  
    this.knex = knex;
    this.config = this.setConfig(knex.client.config.migrations);
  }

• example usage

  n/a

function knex.raw (sql, bindings)

• description and source-code

  raw = function (sql, bindings) {
    (0, _helpers.warn)('global Knex.raw is deprecated, use knex.raw (chain off an initialized knex object)');
    return new _raw2.default().set(sql, bindings);
  }

• example usage

  ...
  // FunctionHelper
  // -------
  function FunctionHelper(client) {
    this.client = client;
  }
  
  FunctionHelper.prototype.now = function () {
    return this.client.raw('CURRENT_TIMESTAMP');
  };
  
  exports.default = FunctionHelper;
  module.exports = exports['default'];
  ...

function knex.runner (client, builder)

• description and source-code

  function Runner(client, builder) {
    this.client = client;
    this.builder = builder;
    this.queries = [];
  
    // The "connection" object is set on the runner when
    // "run" is called.
    this.connection = void 0;
  }

• example usage

  ...
    return (0, _map3.default)(data, function (statement) {
      return _this.client._formatQuery(statement.sql, statement.bindings, tz);
    }).join(';\n');
  };
  
  // Create a new instance of the `Runner`, passing in the current object.
  Target.prototype.then = function () /* onFulfilled, onRejected */{
    var result = this.client.runner(this).run();
    return result.then.apply(result, arguments);
  };
  
  // Add additional "options" to the builder. Typically used for client specific
  // items, like the `mysql` and `sqlite3` drivers.
  Target.prototype.options = function (opts) {
    this._options = this._options || [];
  ...

function knex.seed (knex)

• description and source-code

  function Seeder(knex) {
    this.knex = knex;
    this.config = this.setConfig(knex.client.config.seeds);
  }

• example usage

  n/a

function knex.transaction (client, container, config, outerTx)

• description and source-code

  function Transaction(client, container, config, outerTx) {
    (0, _classCallCheck3.default)(this, Transaction);
  
    var _this = (0, _possibleConstructorReturn3.default)(this, _EventEmitter.call(this));
  
    var txid = _this.txid = (0, _uniqueId3.default)('trx');
  
    _this.client = client;
    _this.outerTx = outerTx;
    _this.trxClient = undefined;
    _this._debug = client.config && client.config.debug;
  
    debug('%s: Starting %s transaction', txid, outerTx ? 'nested' : 'top level');
  
    _this._promise = _bluebird2.default.using(_this.acquireConnection(client, config, txid), function (connection) {
  
      var trxClient = _this.trxClient = makeTxClient(_this, client, connection);
      var init = client.transacting ? _this.savepoint(connection) : _this.begin(connection);
  
      init.then(function () {
        return makeTransactor(_this, connection, trxClient);
      }).then(function (transactor) {
        // If we've returned a "thenable" from the transaction container, assume
        // the rollback and commit are chained to this object's success / failure.
        // Directly thrown errors are treated as automatic rollbacks.
        var result = void 0;
        try {
          result = container(transactor);
        } catch (err) {
          result = _bluebird2.default.reject(err);
        }
        if (result && result.then && typeof result.then === 'function') {
          result.then(function (val) {
            return transactor.commit(val);
          }).catch(function (err) {
            return transactor.rollback(err);
          });
        }
        return null;
      }).catch(function (e) {
        return _this._rejecter(e);
      });
  
      return new _bluebird2.default(function (resolver, rejecter) {
        _this._resolver = resolver;
        _this._rejecter = rejecter;
      });
    });
  
    _this._completed = false;
  
    // If there's a wrapping transaction, we need to wait for any older sibling
    // transactions to settle (commit or rollback) before we can start, and we
    // need to register ourselves with the parent transaction so any younger
    // siblings can wait for us to complete before they can start.
    _this._previousSibling = _bluebird2.default.resolve(true);
    if (outerTx) {
      if (outerTx._lastChild) _this._previousSibling = outerTx._lastChild;
      outerTx._lastChild = _this._promise;
    }
    return _this;
  }

• example usage

  ...
  
  exports.default = Transaction;
  function makeTransactor(trx, connection, trxClient) {
  
  var transactor = (0, _makeKnex2.default)(trxClient);
  
  transactor.transaction = function (container, options) {
    return trxClient.transaction(container, options, trx);
  };
  transactor.savepoint = function (container, options) {
    return transactor.transaction(container, options);
  };
  
  if (trx.client.transacting) {
    transactor.commit = function (value) {
  ...

module knex.Client

function knex.Client ()

• description and source-code

  function Client() {
    var config = arguments.length <= 0 || arguments[0] === undefined ? {} : arguments[0];
  
    this.config = config;
  
    //Client is a required field, so throw error if it's not supplied.
    //If 'this.dialect' is set, then this is a 'super()' call, in which case
    //'client' does not have to be set as it's already assigned on the client prototype.
    if (!this.config.client && !this.dialect) {
      throw new Error('knex: Required configuration option \'client\' is missing.');
    }
  
    this.connectionSettings = (0, _cloneDeep3.default)(config.connection || {});
    if (this.driverName && config.connection) {
      this.initializeDriver();
      if (!config.pool || config.pool && config.pool.max !== 0) {
        this.__cid = clientId();
        this.initializePool(config);
      }
    }
    this.valueForUndefined = this.raw('DEFAULT');
    if (config.useNullAsDefault) {
      this.valueForUndefined = null;
    }
  }

• example usage

  n/a

function knex.Client.super_ ()

• description and source-code

  function EventEmitter() {
    EventEmitter.init.call(this);
  }

• example usage

  n/a

module knex.Client.prototype

function knex.Client.prototype._escapeBinding (val)

• description and source-code

  function finalEscape(val) {
    var ctx = arguments.length <= 1 || arguments[1] === undefined ? {} : arguments[1];
  
    return escapeFn(val, finalEscape, ctx);
  }

• example usage

  n/a

function knex.Client.prototype._formatQuery (sql, bindings, timeZone)

• description and source-code

  function _formatQuery(sql, bindings, timeZone) {
    var _this = this;
  
    bindings = bindings == null ? [] : [].concat(bindings);
    var index = 0;
    return sql.replace(/\\?\?/g, function (match) {
      if (match === '\\?') {
        return '?';
      }
      if (index === bindings.length) {
        return match;
      }
      var value = bindings[index++];
      return _this._escapeBinding(value, { timeZone: timeZone });
    });
  }

• example usage

  ...
  
  Target.prototype.toQuery = function (tz) {
    var _this = this;
  
    var data = this.toSQL(this._method, tz);
    if (!(0, _isArray3.default)(data)) data = [data];
    return (0, _map3.default)(data, function (statement) {
      return _this.client._formatQuery(statement.sql, statement.bindings, tz);
    }).join(';\n');
  };
  
  // Create a new instance of the `Runner`, passing in the current object.
  Target.prototype.then = function () /* onFulfilled, onRejected */{
    var result = this.client.runner(this).run();
    return result.then.apply(result, arguments);
  ...

function knex.Client.prototype.acquireConnection ()

• description and source-code

  function acquireConnection() {
    var _this4 = this;
  
    return new _bluebird2.default(function (resolver, rejecter) {
      if (!_this4.pool) {
        return rejecter(new Error('Unable to acquire a connection'));
      }
      var wasRejected = false;
      var t = setTimeout(function () {
        wasRejected = true;
        rejecter(new _bluebird2.default.TimeoutError('Knex: Timeout acquiring a connection. The pool is probably full. ' + 'Are you
   missing a .transacting(trx) call?'));
      }, _this4.config.acquireConnectionTimeout || 60000);
      _this4.pool.acquire(function (err, connection) {
        clearTimeout(t);
        if (err) {
          return rejecter(err);
        }
        if (wasRejected) {
          _this4.pool.release(connection);
        } else {
          debug('acquired connection from pool: %s', connection.__knexUid);
          resolver(connection);
        }
      });
    });
  }

• example usage

  ...
    // Check whether there's a transaction flag, and that it has a connection.
    ensureConnection: function ensureConnection() {
  var _this2 = this;
  
  return _bluebird2.default.try(function () {
    return _this2.connection || new _bluebird2.default(function (resolver, rejecter) {
      // need to return promise or null from handler to prevent warning from bluebird
      return _this2.client.acquireConnection().then(resolver).catch(_bluebird2.default.
  TimeoutError, function (error) {
        if (_this2.builder) {
          error.sql = _this2.builder.sql;
          error.bindings = _this2.builder.bindings;
        }
        throw error;
      }).catch(rejecter);
    });
  ...

function knex.Client.prototype.assertCanCancelQuery ()

• description and source-code

  function assertCanCancelQuery() {
    if (!this.canCancelQuery) {
      throw new Error("Query cancelling not supported for this dialect");
    }
  }

• example usage

  ...
    var _ref = arguments.length <= 1 || arguments[1] === undefined ? {} : arguments[1];
  
    var cancel = _ref.cancel;
  
    if ((0, _isNumber3.default)(ms) && ms > 0) {
      this._timeout = ms;
      if (cancel) {
        this.client.assertCanCancelQuery();
        this._cancelOnTimeout = true;
      }
    }
    return this;
  },
  ...

function knex.Client.prototype.cancelQuery ()

• description and source-code

  function cancelQuery() {
    throw new Error("Query cancelling not supported for this dialect");
  }

• example usage

  ...
  var timeout = obj.timeout;
  var sql = obj.sql;
  var bindings = obj.bindings;
  
  
  var cancelQuery = void 0;
  if (obj.cancelOnTimeout) {
    cancelQuery = _this.client.cancelQuery(_this.connection);
  } else {
    cancelQuery = _bluebird2.default.resolve();
  }
  
  return cancelQuery.catch(function (cancelError) {
    // cancellation failed
    throw (0, _assign3.default)(cancelError, {
  ...

function knex.Client.prototype.columnBuilder (tableBuilder, type, args)

• description and source-code

  function columnBuilder(tableBuilder, type, args) {
    return new _columnbuilder2.default(this, tableBuilder, type, args);
  }

• example usage

  n/a

function knex.Client.prototype.columnCompiler (tableBuilder, columnBuilder)

• description and source-code

  function columnCompiler(tableBuilder, columnBuilder) {
    return new _columncompiler2.default(this, tableBuilder, columnBuilder);
  }

• example usage

  n/a

function knex.Client.prototype.database ()

• description and source-code

  function database() {
    return this.connectionSettings.database;
  }

• example usage

  n/a

function knex.Client.prototype.destroy (callback)

• description and source-code

  function destroy(callback) {
    var _this6 = this;
  
    var promise = new _bluebird2.default(function (resolver) {
      if (!_this6.pool) {
        return resolver();
      }
      _this6.pool.drain(function () {
        _this6.pool.destroyAllNow(function () {
          _this6.pool = undefined;
          resolver();
        });
      });
    });
  
    // Allow either a callback or promise interface for destruction.
    if (typeof callback === 'function') {
      promise.asCallback(callback);
    } else {
      return promise;
    }
  }

• example usage

  n/a

function knex.Client.prototype.formatter ()

• description and source-code

  function formatter() {
    return new _formatter2.default(this);
  }

• example usage

  ...
  return this.toQuery();
    },
  
  
    // Returns the raw sql for the query.
    toSQL: function toSQL(method, tz) {
  var obj = void 0;
  var formatter = this.client.formatter();
  
  if (Array.isArray(this.bindings)) {
    obj = replaceRawArrBindings(this, formatter);
  } else if (this.bindings && (0, _isPlainObject3.default)(this.bindings)) {
    obj = replaceKeyBindings(this, formatter);
  } else {
    obj = {
  ...

function knex.Client.prototype.initializeDriver ()

• description and source-code

  function initializeDriver() {
    try {
      this.driver = this._driver();
    } catch (e) {
      helpers.exit('Knex: run\n$ npm install ' + this.driverName + ' --save\n' + e.stack);
    }
  }

• example usage

  n/a

function knex.Client.prototype.initializePool (config)

• description and source-code

  function initializePool(config) {
    if (this.pool) {
      helpers.warn('The pool has already been initialized');
      return;
    }
    this.pool = new _genericPool.Pool((0, _assign3.default)(this.poolDefaults(config.pool || {}), config.pool));
  }

• example usage

  n/a

function knex.Client.prototype.poolDefaults (poolConfig)

• description and source-code

  function poolDefaults(poolConfig) {
    var _this3 = this;
  
    var name = this.dialect + ':' + this.driverName + ':' + this.__cid;
    return {
      min: 2,
      max: 10,
      name: name,
      log: function log(str, level) {
        if (level === 'info') {
          debugPool(level.toUpperCase() + ' pool ' + name + ' - ' + str);
        }
      },
  
      create: function create(callback) {
        _this3.acquireRawConnection().tap(function (connection) {
          connection.__knexUid = (0, _uniqueId3.default)('__knexUid');
          if (poolConfig.afterCreate) {
            return _bluebird2.default.promisify(poolConfig.afterCreate)(connection);
          }
        }).asCallback(callback);
      },
      destroy: function destroy(connection) {
        if (poolConfig.beforeDestroy) {
          helpers.warn('\n            beforeDestroy is deprecated, please open an issue if you use this\n            to discuss alternative
   apis\n          ');
          poolConfig.beforeDestroy(connection, function () {});
        }
        if (connection !== void 0) {
          _this3.destroyRawConnection(connection);
        }
      },
      validate: function validate(connection) {
        if (connection.__knex__disposed) {
          helpers.warn('Connection Error: ' + connection.__knex__disposed);
          return false;
        }
        return _this3.validateConnection(connection);
      }
    };
  }

• example usage

  n/a

function knex.Client.prototype.prepBindings (bindings)

• description and source-code

  function prepBindings(bindings) {
    return bindings;
  }

• example usage

  n/a

function knex.Client.prototype.query (connection, obj)

• description and source-code

  function query(connection, obj) {
    var _this2 = this;
  
    if (typeof obj === 'string') obj = { sql: obj };
    obj.bindings = this.prepBindings(obj.bindings);
    debugQuery(obj.sql);
    this.emit('query', (0, _assign3.default)({ __knexUid: connection.__knexUid }, obj));
    debugBindings(obj.bindings);
    return this._query(connection, obj).catch(function (err) {
      err.message = _this2._formatQuery(obj.sql, obj.bindings) + ' - ' + err.message;
      _this2.emit('query-error', err, (0, _assign3.default)({ __knexUid: connection.__knexUid }, obj));
      throw err;
    });
  }

• example usage

  ...
    if (runner.builder._debug) {
      helpers.debugLog(sql);
    }
  
    if ((0, _isArray3.default)(sql)) {
      return runner.queryArray(sql);
    }
    return runner.query(sql);
  })
  
  // If there are any "error" listeners, we fire an error event
  // and then re-throw the error to be eventually handled by
  // the promise chain. Useful if you're wrapping in a custom `Promise`.
  .catch(function (err) {
    if (runner.builder._events && runner.builder._events.error) {
  ...

function knex.Client.prototype.queryBuilder ()

• description and source-code

  function queryBuilder() {
    return new _builder2.default(this);
  }

• example usage

  ...
  
  
    Formatter.prototype.compileCallback = function compileCallback(callback, method) {
  var client = this.client;
  
  // Build the callback
  
  var builder = client.queryBuilder();
  callback.call(builder, builder);
  
  // Compile the callback, using the current formatter (to track all bindings).
  var compiler = client.queryCompiler(builder);
  compiler.formatter = this;
  
  // Return the compiled & parameterized sql.
  ...

function knex.Client.prototype.queryCompiler (builder)

• description and source-code

  function queryCompiler(builder) {
    return new _compiler2.default(this, builder);
  }

• example usage

  ...
    }
    return this.unwrapRaw(value, true) || '?';
  };
  
  Formatter.prototype.unwrapRaw = function unwrapRaw(value, isParameter) {
    var query = void 0;
    if (value instanceof _builder2.default) {
      query = this.client.queryCompiler(value).toSQL();
      if (query.bindings) {
        this.bindings = this.bindings.concat(query.bindings);
      }
      return this.outputQuery(query, isParameter);
    }
    if (value instanceof _raw2.default) {
      value.client = this.client;
  ...

function knex.Client.prototype.raw ()

• description and source-code

  function raw() {
    var _ref;
  
    return (_ref = new _raw2.default(this)).set.apply(_ref, arguments);
  }

• example usage

  ...
  // FunctionHelper
  // -------
  function FunctionHelper(client) {
    this.client = client;
  }
  
  FunctionHelper.prototype.now = function () {
    return this.client.raw('CURRENT_TIMESTAMP');
  };
  
  exports.default = FunctionHelper;
  module.exports = exports['default'];
  ...

function knex.Client.prototype.releaseConnection (connection)

• description and source-code

  function releaseConnection(connection) {
    var _this5 = this;
  
    return new _bluebird2.default(function (resolver) {
      debug('releasing connection to pool: %s', connection.__knexUid);
      _this5.pool.release(connection);
      resolver();
    });
  }

• example usage

  ...
              error.bindings = _this2.builder.bindings;
            }
            throw error;
          }).catch(rejecter);
        });
      }).disposer(function () {
        // need to return promise or null from handler to prevent warning from bluebird
        return _this2.client.releaseConnection(_this2.connection);
      });
    }
  });
  
  exports.default = Runner;
  module.exports = exports['default'];
  ...

function knex.Client.prototype.runner (connection)

• description and source-code

  function runner(connection) {
    return new _runner2.default(this, connection);
  }

• example usage

  ...
    return (0, _map3.default)(data, function (statement) {
      return _this.client._formatQuery(statement.sql, statement.bindings, tz);
    }).join(';\n');
  };
  
  // Create a new instance of the `Runner`, passing in the current object.
  Target.prototype.then = function () /* onFulfilled, onRejected */{
    var result = this.client.runner(this).run();
    return result.then.apply(result, arguments);
  };
  
  // Add additional "options" to the builder. Typically used for client specific
  // items, like the `mysql` and `sqlite3` drivers.
  Target.prototype.options = function (opts) {
    this._options = this._options || [];
  ...

function knex.Client.prototype.schemaBuilder ()

• description and source-code

  function schemaBuilder() {
    return new _builder4.default(this);
  }

• example usage

  n/a

function knex.Client.prototype.schemaCompiler (builder)

• description and source-code

  function schemaCompiler(builder) {
    return new _compiler4.default(this, builder);
  }

• example usage

  n/a

function knex.Client.prototype.stream (connection, obj, _stream, options)

• description and source-code

  function stream(connection, obj, _stream, options) {
    if (typeof obj === 'string') obj = { sql: obj };
    this.emit('query', (0, _assign3.default)({ __knexUid: connection.__knexUid }, obj));
    debugQuery(obj.sql);
    obj.bindings = this.prepBindings(obj.bindings);
    debugBindings(obj.bindings);
    return this._stream(connection, obj, _stream, options);
  }

• example usage

  ...
      }
    }
    return this;
  };
  
  // Initializes a stream.
  Target.prototype.stream = function (options) {
    return this.client.runner(this).stream(options);
  };
  
  // Initialize a stream & pipe automatically.
  Target.prototype.pipe = function (writable, options) {
    return this.client.runner(this).pipe(writable, options);
  };
  ...

function knex.Client.prototype.tableBuilder (type, tableName, fn)

• description and source-code

  function tableBuilder(type, tableName, fn) {
    return new _tablebuilder2.default(this, type, tableName, fn);
  }

• example usage

  n/a

function knex.Client.prototype.tableCompiler (tableBuilder)

• description and source-code

  function tableCompiler(tableBuilder) {
    return new _tablecompiler2.default(this, tableBuilder);
  }

• example usage

  n/a

function knex.Client.prototype.toString ()

• description and source-code

  function toString() {
    return '[object KnexClient]';
  }

• example usage

  n/a

function knex.Client.prototype.transaction (container, config, outerTx)

• description and source-code

  function transaction(container, config, outerTx) {
    return new _transaction2.default(this, container, config, outerTx);
  }

• example usage

  ...
  
  exports.default = Transaction;
  function makeTransactor(trx, connection, trxClient) {
  
  var transactor = (0, _makeKnex2.default)(trxClient);
  
  transactor.transaction = function (container, options) {
    return trxClient.transaction(container, options, trx);
  };
  transactor.savepoint = function (container, options) {
    return transactor.transaction(container, options);
  };
  
  if (trx.client.transacting) {
    transactor.commit = function (value) {
  ...

function knex.Client.prototype.validateConnection (connection)

• description and source-code

  function validateConnection(connection) {
    return true;
  }

• example usage

  n/a

function knex.Client.prototype.wrapIdentifier (value)

• description and source-code

  function wrapIdentifier(value) {
    return value !== '*' ? '"' + value.replace(/"/g, '""') + '"' : '*';
  }

• example usage

  ...
    var raw = this.unwrapRaw(value);
    if (raw) return raw;
    if (typeof value === 'number') return value;
    return this._wrapString(value + '');
  };
  
  Formatter.prototype.wrapAsIdentifier = function wrapAsIdentifier(value) {
    return this.client.wrapIdentifier((value || '').trim());
  };
  
  Formatter.prototype.alias = function alias(first, second) {
    return first + ' as ' + second;
  };
  
  // The operator method takes a value and returns something or other.
  ...

module knex.formatter

function knex.formatter (client)

• description and source-code

  function Formatter(client) {
    (0, _classCallCheck3.default)(this, Formatter);
  
    this.client = client;
    this.bindings = [];
  }

• example usage

  ...
  return this.toQuery();
    },
  
  
    // Returns the raw sql for the query.
    toSQL: function toSQL(method, tz) {
  var obj = void 0;
  var formatter = this.client.formatter();
  
  if (Array.isArray(this.bindings)) {
    obj = replaceRawArrBindings(this, formatter);
  } else if (this.bindings && (0, _isPlainObject3.default)(this.bindings)) {
    obj = replaceKeyBindings(this, formatter);
  } else {
    obj = {
  ...

module knex.formatter.prototype

function knex.formatter.prototype._wrapString (value)

• description and source-code

  function _wrapString(value) {
    var asIndex = value.toLowerCase().indexOf(' as ');
    if (asIndex !== -1) {
      var first = value.slice(0, asIndex);
      var second = value.slice(asIndex + 4);
      return this.alias(this.wrap(first), this.wrapAsIdentifier(second));
    }
    var wrapped = [];
    var i = -1;
    var segments = value.split('.');
    while (++i < segments.length) {
      value = segments[i];
      if (i === 0 && segments.length > 1) {
        wrapped.push(this.wrap((value || '').trim()));
      } else {
        wrapped.push(this.client.wrapIdentifier((value || '').trim()));
      }
    }
    return wrapped.join('.');
  }

• example usage

  ...
  Formatter.prototype.wrap = function wrap(value) {
    if (typeof value === 'function') {
      return this.outputQuery(this.compileCallback(value), true);
    }
    var raw = this.unwrapRaw(value);
    if (raw) return raw;
    if (typeof value === 'number') return value;
    return this._wrapString(value + '');
  };
  
  Formatter.prototype.wrapAsIdentifier = function wrapAsIdentifier(value) {
    return this.client.wrapIdentifier((value || '').trim());
  };
  
  Formatter.prototype.alias = function alias(first, second) {
  ...

function knex.formatter.prototype.alias (first, second)

• description and source-code

  function alias(first, second) {
    return first + ' as ' + second;
  }

• example usage

  ...
  
  
  Formatter.prototype.outputQuery = function outputQuery(compiled, isParameter) {
    var sql = compiled.sql || '';
    if (sql) {
      if ((compiled.method === 'select' || compiled.method === 'first') && (isParameter || compiled.
  as)) {
        sql = '(' + sql + ')';
        if (compiled.as) return this.alias(sql, this.wrap(compiled.as));
      }
    }
    return sql;
  };
  
  // Coerce to string to prevent strange errors when it's not a string.
  ...

function knex.formatter.prototype.columnize (target)

• description and source-code

  function columnize(target) {
    var columns = typeof target === 'string' ? [target] : target;
    var str = '',
        i = -1;
    while (++i < columns.length) {
      if (i > 0) str += ', ';
      str += this.wrap(columns[i]);
    }
    return str;
  }

• example usage

  ...
    if (match === '\\?') {
      return match;
    }
  
    var value = values[index++];
  
    if (match === '??') {
      return formatter.columnize(value);
    }
    return formatter.parameter(value);
  });
  
  if (expectedBindings !== index) {
    throw new Error('Expected ' + expectedBindings + ' bindings, saw ' + index);
  }
  ...

function knex.formatter.prototype.compileCallback (callback, method)

• description and source-code

  function compileCallback(callback, method) {
    var client = this.client;
  
    // Build the callback
  
    var builder = client.queryBuilder();
    callback.call(builder, builder);
  
    // Compile the callback, using the current formatter (to track all bindings).
    var compiler = client.queryCompiler(builder);
    compiler.formatter = this;
  
    // Return the compiled & parameterized sql.
    return compiler.toSQL(method || 'select');
  }

• example usage

  ...
  
  // Checks whether a value is a function... if it is, we compile it
  // otherwise we check whether it's a raw
  
  
  Formatter.prototype.parameter = function parameter(value) {
    if (typeof value === 'function') {
      return this.outputQuery(this.compileCallback(value), true);
    }
    return this.unwrapRaw(value, true) || '?';
  };
  
  Formatter.prototype.unwrapRaw = function unwrapRaw(value, isParameter) {
    var query = void 0;
    if (value instanceof _builder2.default) {
  ...

function knex.formatter.prototype.direction (value)

• description and source-code

  function direction(value) {
    var raw = this.unwrapRaw(value);
    if (raw) return raw;
    return orderBys.indexOf((value || '').toLowerCase()) !== -1 ? value : 'asc';
  }

• example usage

  n/a

function knex.formatter.prototype.operator (value)

• description and source-code

  function operator(value) {
    var raw = this.unwrapRaw(value);
    if (raw) return raw;
    if (operators[(value || '').toLowerCase()] !== true) {
      throw new TypeError('The operator "' + value + '" is not permitted');
    }
    return value;
  }

• example usage

  n/a

function knex.formatter.prototype.outputQuery (compiled, isParameter)

• description and source-code

  function outputQuery(compiled, isParameter) {
    var sql = compiled.sql || '';
    if (sql) {
      if ((compiled.method === 'select' || compiled.method === 'first') && (isParameter || compiled.as)) {
        sql = '(' + sql + ')';
        if (compiled.as) return this.alias(sql, this.wrap(compiled.as));
      }
    }
    return sql;
  }

• example usage

  ...
  
  // Checks whether a value is a function... if it is, we compile it
  // otherwise we check whether it's a raw
  
  
  Formatter.prototype.parameter = function parameter(value) {
    if (typeof value === 'function') {
      return this.outputQuery(this.compileCallback(value), true);
    }
    return this.unwrapRaw(value, true) || '?';
  };
  
  Formatter.prototype.unwrapRaw = function unwrapRaw(value, isParameter) {
    var query = void 0;
    if (value instanceof _builder2.default) {
  ...

function knex.formatter.prototype.parameter (value)

• description and source-code

  function parameter(value) {
    if (typeof value === 'function') {
      return this.outputQuery(this.compileCallback(value), true);
    }
    return this.unwrapRaw(value, true) || '?';
  }

• example usage

  ...
  };
  
  // Turns a list of values into a list of ?'s, joining them with commas unless
  // a "joining" value is specified (e.g. ' and ')
  
  
  Formatter.prototype.parameterize = function parameterize(values, notSetValue) {
    if (typeof values === 'function') return this.parameter(values);
    values = Array.isArray(values) ? values : [values];
    var str = '',
        i = -1;
    while (++i < values.length) {
      if (i > 0) str += ', ';
      str += this.parameter(values[i] === undefined ? notSetValue : values[i]);
    }
  ...

function knex.formatter.prototype.parameterize (values, notSetValue)

• description and source-code

  function parameterize(values, notSetValue) {
    if (typeof values === 'function') return this.parameter(values);
    values = Array.isArray(values) ? values : [values];
    var str = '',
        i = -1;
    while (++i < values.length) {
      if (i > 0) str += ', ';
      str += this.parameter(values[i] === undefined ? notSetValue : values[i]);
    }
    return str;
  }

• example usage

  n/a

function knex.formatter.prototype.rawOrFn (value, method)

• description and source-code

  function rawOrFn(value, method) {
    if (typeof value === 'function') {
      return this.outputQuery(this.compileCallback(value, method));
    }
    return this.unwrapRaw(value) || '';
  }

• example usage

  n/a

function knex.formatter.prototype.unwrapRaw (value, isParameter)

• description and source-code

  function unwrapRaw(value, isParameter) {
    var query = void 0;
    if (value instanceof _builder2.default) {
      query = this.client.queryCompiler(value).toSQL();
      if (query.bindings) {
        this.bindings = this.bindings.concat(query.bindings);
      }
      return this.outputQuery(query, isParameter);
    }
    if (value instanceof _raw2.default) {
      value.client = this.client;
      query = value.toSQL();
      if (query.bindings) {
        this.bindings = this.bindings.concat(query.bindings);
      }
      return query.sql;
    }
    if (isParameter) {
      this.bindings.push(value);
    }
  }

• example usage

  ...
  // otherwise we check whether it's a raw
  
  
  Formatter.prototype.parameter = function parameter(value) {
    if (typeof value === 'function') {
      return this.outputQuery(this.compileCallback(value), true);
    }
    return this.unwrapRaw(value, true) || '?';
  };
  
  Formatter.prototype.unwrapRaw = function unwrapRaw(value, isParameter) {
    var query = void 0;
    if (value instanceof _builder2.default) {
      query = this.client.queryCompiler(value).toSQL();
      if (query.bindings) {
  ...

function knex.formatter.prototype.wrap (value)

• description and source-code

  function wrap(value) {
    if (typeof value === 'function') {
      return this.outputQuery(this.compileCallback(value), true);
    }
    var raw = this.unwrapRaw(value);
    if (raw) return raw;
    if (typeof value === 'number') return value;
    return this._wrapString(value + '');
  }

• example usage

  ...
  
  Formatter.prototype.columnize = function columnize(target) {
    var columns = typeof target === 'string' ? [target] : target;
    var str = '',
        i = -1;
    while (++i < columns.length) {
      if (i > 0) str += ', ';
      str += this.wrap(columns[i]);
    }
    return str;
  };
  
  // Turns a list of values into a list of ?'s, joining them with commas unless
  // a "joining" value is specified (e.g. ' and ')
  ...

function knex.formatter.prototype.wrapAsIdentifier (value)

• description and source-code

  function wrapAsIdentifier(value) {
    return this.client.wrapIdentifier((value || '').trim());
  }

• example usage

  ...
  
  
    Formatter.prototype._wrapString = function _wrapString(value) {
  var asIndex = value.toLowerCase().indexOf(' as ');
  if (asIndex !== -1) {
    var first = value.slice(0, asIndex);
    var second = value.slice(asIndex + 4);
    return this.alias(this.wrap(first), this.wrapAsIdentifier(second));
  }
  var wrapped = [];
  var i = -1;
  var segments = value.split('.');
  while (++i < segments.length) {
    value = segments[i];
    if (i === 0 && segments.length > 1) {
  ...

module knex.functionhelper

function knex.functionhelper (client)

• description and source-code

  function FunctionHelper(client) {
    this.client = client;
  }

• example usage

  n/a

module knex.functionhelper.prototype

function knex.functionhelper.prototype.now ()

• description and source-code

  now = function () {
    return this.client.raw('CURRENT_TIMESTAMP');
  }

• example usage

  n/a

module knex.helpers

function knex.helpers.containsUndefined (mixed)

• description and source-code

  function containsUndefined(mixed) {
    var argContainsUndefined = false;
  
    if ((0, _isTypedArray3.default)(mixed)) return false;
  
    if (mixed && (0, _isFunction3.default)(mixed.toSQL)) {
      //Any QueryBuilder or Raw will automatically be validated during compile.
      return argContainsUndefined;
    }
  
    if ((0, _isArray3.default)(mixed)) {
      for (var i = 0; i < mixed.length; i++) {
        if (argContainsUndefined) break;
        argContainsUndefined = this.containsUndefined(mixed[i]);
      }
    } else if ((0, _isObject3.default)(mixed)) {
      for (var key in mixed) {
        if (argContainsUndefined) break;
        argContainsUndefined = this.containsUndefined(mixed[key]);
      }
    } else {
      argContainsUndefined = (0, _isUndefined3.default)(mixed);
    }
  
    return argContainsUndefined;
  }

• example usage

  ...
    //Any QueryBuilder or Raw will automatically be validated during compile.
    return argContainsUndefined;
  }
  
  if ((0, _isArray3.default)(mixed)) {
    for (var i = 0; i < mixed.length; i++) {
      if (argContainsUndefined) break;
      argContainsUndefined = this.containsUndefined(mixed[i]);
    }
  } else if ((0, _isObject3.default)(mixed)) {
    for (var key in mixed) {
      if (argContainsUndefined) break;
      argContainsUndefined = this.containsUndefined(mixed[key]);
    }
  } else {
  ...

function knex.helpers.debugLog (msg)

• description and source-code

  function debugLog(msg) {
    console.log(msg);
  }

• example usage

  ...
    runner.connection = connection;
  
    runner.client.emit('start', runner.builder);
    runner.builder.emit('start', runner.builder);
    var sql = runner.builder.toSQL();
  
    if (runner.builder._debug) {
      helpers.debugLog(sql);
    }
  
    if ((0, _isArray3.default)(sql)) {
      return runner.queryArray(sql);
    }
    return runner.query(sql);
  })
  ...

function knex.helpers.deprecate (method, alternate)

• description and source-code

  function deprecate(method, alternate) {
    warn(method + ' is deprecated, please use ' + alternate);
  }

• example usage

  n/a

function knex.helpers.error (msg)

• description and source-code

  function error(msg) {
    console.log(_chalk2.default.red('Knex:Error ' + msg));
  }

• example usage

  ...
  // .map over the results
  .map(function(row) {
    console.log(row);
  })
  
  // Finally, add a .catch handler for the promise chain
  .catch(function(e) {
    console.error(e);
  });
  ```
  ...

function knex.helpers.exit (msg)

• description and source-code

  function exit(msg) {
    console.log(_chalk2.default.red(msg));
    process.exit(1);
  }

• example usage

  ...
  // Used to warn about incorrect use, without error'ing
  function warn(msg) {
  console.log(_chalk2.default.yellow('Knex:warning - ' + msg));
  }
  
  function exit(msg) {
  console.log(_chalk2.default.red(msg));
  process.exit(1);
  }
  
  function containsUndefined(mixed) {
  var argContainsUndefined = false;
  
  if ((0, _isTypedArray3.default)(mixed)) return false;
  ...

function knex.helpers.normalizeArr ()

• description and source-code

  function normalizeArr() {
    var args = new Array(arguments.length);
    for (var i = 0; i < args.length; i++) {
      args[i] = arguments[i];
    }
    if (Array.isArray(args[0])) {
      return args[0];
    }
    return args;
  }

• example usage

  n/a

function knex.helpers.skim (data)

• description and source-code

  function skim(data) {
    return (0, _map3.default)(data, function (obj) {
      return (0, _pick3.default)(obj, (0, _keys3.default)(obj));
    });
  }

• example usage

  n/a

function knex.helpers.warn (msg)

• description and source-code

  function warn(msg) {
    console.log(_chalk2.default.yellow('Knex:warning - ' + msg));
  }

• example usage

  ...
    return this;
  };
  
  // Set the transaction object for this query.
  Target.prototype.transacting = function (t) {
    if (t && t.client) {
      if (!t.client.transacting) {
        helpers.warn('Invalid transaction value: ' + t.client);
      } else {
        this.client = t.client;
      }
    }
    return this;
  };
  ...

module knex.migrate

function knex.migrate (knex)

• description and source-code

  function Migrator(knex) {
    (0, _classCallCheck3.default)(this, Migrator);
  
    this.knex = knex;
    this.config = this.setConfig(knex.client.config.migrations);
  }

• example usage

  n/a

module knex.migrate.prototype

function knex.migrate.prototype._absoluteConfigDir ()

• description and source-code

  function _absoluteConfigDir() {
    return _path2.default.resolve(process.cwd(), this.config.directory);
  }

• example usage

  n/a

function knex.migrate.prototype._createMigrationLockTable (tableName)

• description and source-code

  function _createMigrationLockTable(tableName) {
    return this.knex.schema.createTableIfNotExists(tableName, function (t) {
      t.integer('is_locked');
    });
  }

• example usage

  n/a

function knex.migrate.prototype._createMigrationTable (tableName)

• description and source-code

  function _createMigrationTable(tableName) {
    return this.knex.schema.createTableIfNotExists(tableName, function (t) {
      t.increments();
      t.string('name');
      t.integer('batch');
      t.timestamp('migration_time');
    });
  }

• example usage

  n/a

function knex.migrate.prototype._ensureFolder ()

• description and source-code

  function _ensureFolder() {
    var dir = this._absoluteConfigDir();
    return _bluebird2.default.promisify(_fs2.default.stat, { context: _fs2.default })(dir).catch(function () {
      return _bluebird2.default.promisify(_mkdirp2.default)(dir);
    });
  }

• example usage

  n/a

function knex.migrate.prototype._ensureTable ()

• description and source-code

  function _ensureTable() {
    var _this5 = this;
  
    var table = this.config.tableName;
    var lockTable = this._getLockTableName();
    return this.knex.schema.hasTable(table).then(function (exists) {
      return !exists && _this5._createMigrationTable(table);
    }).then(function () {
      return _this5.knex.schema.hasTable(lockTable);
    }).then(function (exists) {
      return !exists && _this5._createMigrationLockTable(lockTable);
    }).then(function () {
      return _this5.knex(lockTable).select('*');
    }).then(function (data) {
      return !data.length && _this5.knex(lockTable).insert({ is_locked: 0 });
    });
  }

• example usage

  n/a

function knex.migrate.prototype._freeLock ()

• description and source-code

  function _freeLock() {
    var tableName = this._getLockTableName();
    return this.knex(tableName).update({ is_locked: 0 });
  }

• example usage

  n/a

function knex.migrate.prototype._generateStubTemplate ()

• description and source-code

  function _generateStubTemplate() {
    var stubPath = this.config.stub || _path2.default.join(__dirname, 'stub', this.config.extension + '.stub');
    return _bluebird2.default.promisify(_fs2.default.readFile, { context: _fs2.default })(stubPath).then(function (stub) {
      return (0, _template3.default)(stub.toString(), { variable: 'd' });
    });
  }

• example usage

  n/a

function knex.migrate.prototype._getLastBatch ()

• description and source-code

  function _getLastBatch() {
    var tableName = this.config.tableName;
  
    return this.knex(tableName).where('batch', function (qb) {
      qb.max('batch').from(tableName);
    }).orderBy('id', 'desc');
  }

• example usage

  n/a

function knex.migrate.prototype._getLock ()

• description and source-code

  function _getLock() {
    var _this6 = this;
  
    return this.knex.transaction(function (trx) {
      return _this6._isLocked(trx).then(function (isLocked) {
        if (isLocked) {
          throw new Error("Migration table is already locked");
        }
      }).then(function () {
        return _this6._lockMigrations(trx);
      });
    }).catch(function (err) {
      throw new LockError(err.message);
    });
  }

• example usage

  n/a

function knex.migrate.prototype._getLockTableName ()

• description and source-code

  function _getLockTableName() {
    return this.config.tableName + '_lock';
  }

• example usage

  n/a

function knex.migrate.prototype._isLocked (trx)

• description and source-code

  function _isLocked(trx) {
    var tableName = this._getLockTableName();
    return this.knex(tableName).transacting(trx).forUpdate().select('*').then(function (data) {
      return data[0].is_locked;
    });
  }

• example usage

  n/a

function knex.migrate.prototype._latestBatchNumber ()

• description and source-code

  function _latestBatchNumber() {
    return this.knex(this.config.tableName).max('batch as max_batch').then(function (obj) {
      return obj[0].max_batch || 0;
    });
  }

• example usage

  n/a

function knex.migrate.prototype._listAll (config)

• description and source-code

  function _listAll(config) {
    this.config = this.setConfig(config);
    return _bluebird2.default.promisify(_fs2.default.readdir, { context: _fs2.default })(this._absoluteConfigDir()).then(function (
  migrations) {
      return (0, _filter3.default)(migrations, function (value) {
        var extension = _path2.default.extname(value);
        return (0, _includes3.default)(SUPPORTED_EXTENSIONS, extension);
      }).sort();
    });
  }

• example usage

  n/a

function knex.migrate.prototype._listCompleted ()

• description and source-code

  function _listCompleted() {
    var _this8 = this;
  
    var tableName = this.config.tableName;
  
    return this._ensureTable(tableName).then(function () {
      return _this8.knex(tableName).orderBy('id').select('name');
    }).then(function (migrations) {
      return (0, _map3.default)(migrations, 'name');
    });
  }

• example usage

  n/a

function knex.migrate.prototype._lockMigrations (trx)

• description and source-code

  function _lockMigrations(trx) {
    var tableName = this._getLockTableName();
    return this.knex(tableName).transacting(trx).update({ is_locked: 1 });
  }

• example usage

  n/a

function knex.migrate.prototype._migrationData ()

• description and source-code

  function _migrationData() {
    return _bluebird2.default.all([this._listAll(), this._listCompleted()]);
  }

• example usage

  n/a

function knex.migrate.prototype._runBatch (migrations, direction)

• description and source-code

  function _runBatch(migrations, direction) {
    var _this7 = this;
  
    return this._getLock().then(function () {
      return _bluebird2.default.all((0, _map3.default)(migrations, (0, _bind3.default)(_this7._validateMigrationStructure, _this7)));
    }).then(function () {
      return _this7._latestBatchNumber();
    }).then(function (batchNo) {
      if (direction === 'up') batchNo++;
      return batchNo;
    }).then(function (batchNo) {
      return _this7._waterfallBatch(batchNo, migrations, direction);
    }).tap(function () {
      return _this7._freeLock();
    }).catch(function (error) {
      var cleanupReady = _bluebird2.default.resolve();
  
      if (error instanceof LockError) {
        // If locking error do not free the lock.
        helpers.warn('Can\'t take lock to run migrations: ' + error.message);
        helpers.warn('If you are sure migrations are not running you can release the ' + 'lock manually by deleting all the rows from
   migrations lock ' + 'table: ' + _this7._getLockTableName());
      } else {
        helpers.warn('migrations failed with error: ' + error.message);
        // If the error was not due to a locking issue, then remove the lock.
        cleanupReady = _this7._freeLock();
      }
  
      return cleanupReady.finally(function () {
        throw error;
      });
    });
  }

• example usage

  n/a

function knex.migrate.prototype._transaction (migration, direction, name)

• description and source-code

  function _transaction(migration, direction, name) {
    return this.knex.transaction(function (trx) {
      return warnPromise(migration[direction](trx, _bluebird2.default), name, function () {
        trx.commit();
      });
    });
  }

• example usage

  n/a

function knex.migrate.prototype._useTransaction (migration, allTransactionsDisabled)

• description and source-code

  function _useTransaction(migration, allTransactionsDisabled) {
    var singleTransactionValue = (0, _get3.default)(migration, 'config.transaction');
  
    return (0, _isBoolean3.default)(singleTransactionValue) ? singleTransactionValue : !allTransactionsDisabled;
  }

• example usage

  n/a

function knex.migrate.prototype._validateMigrationStructure (name)

• description and source-code

  function _validateMigrationStructure(name) {
    var migration = require(_path2.default.join(this._absoluteConfigDir(), name));
    if (typeof migration.up !== 'function' || typeof migration.down !== 'function') {
      throw new Error('Invalid migration: ' + name + ' must have both an up and down function');
    }
    return name;
  }

• example usage

  n/a

function knex.migrate.prototype._waterfallBatch (batchNo, migrations, direction)

• description and source-code

  function _waterfallBatch(batchNo, migrations, direction) {
    var _this9 = this;
  
    var knex = this.knex;
    var _config = this.config;
    var tableName = _config.tableName;
    var disableTransactions = _config.disableTransactions;
  
    var directory = this._absoluteConfigDir();
    var current = _bluebird2.default.bind({ failed: false, failedOn: 0 });
    var log = [];
    (0, _each3.default)(migrations, function (migration) {
      var name = migration;
      migration = require(directory + '/' + name);
  
      // We're going to run each of the migrations in the current "up".
      current = current.then(function () {
        if (_this9._useTransaction(migration, disableTransactions)) {
          return _this9._transaction(migration, direction, name);
        }
        return warnPromise(migration[direction](knex, _bluebird2.default), name);
      }).then(function () {
        log.push(_path2.default.join(directory, name));
        if (direction === 'up') {
          return knex(tableName).insert({
            name: name,
            batch: batchNo,
            migration_time: new Date()
          });
        }
        if (direction === 'down') {
          return knex(tableName).where({ name: name }).del();
        }
      });
    });
  
    return current.thenReturn([batchNo, log]);
  }

• example usage

  n/a

function knex.migrate.prototype._writeNewMigration (name, tmpl)

• description and source-code

  function _writeNewMigration(name, tmpl) {
    var config = this.config;
  
    var dir = this._absoluteConfigDir();
    if (name[0] === '-') name = name.slice(1);
    var filename = yyyymmddhhmmss() + '_' + name + '.' + config.extension;
    return _bluebird2.default.promisify(_fs2.default.writeFile, { context: _fs2.default })(_path2.default.join(dir, filename), tmpl
  (config.variables || {})).return(_path2.default.join(dir, filename));
  }

• example usage

  n/a

function knex.migrate.prototype.currentVersion (config)

• description and source-code

  function currentVersion(config) {
    this.config = this.setConfig(config);
    return this._listCompleted(config).then(function (completed) {
      var val = (0, _max3.default)((0, _map3.default)(completed, function (value) {
        return value.split('_')[0];
      }));
      return (0, _isUndefined3.default)(val) ? 'none' : val;
    });
  }

• example usage

  n/a

function knex.migrate.prototype.forceFreeMigrationsLock (config)

• description and source-code

  function forceFreeMigrationsLock(config) {
    var _this3 = this;
  
    this.config = this.setConfig(config);
    var lockTable = this._getLockTableName();
    return this.knex.schema.hasTable(lockTable).then(function (exist) {
      return exist && _this3._freeLock();
    });
  }

• example usage

  n/a

function knex.migrate.prototype.latest (config)

• description and source-code

  function latest(config) {
    var _this = this;
  
    this.config = this.setConfig(config);
    return this._migrationData().tap(validateMigrationList).spread(function (all, completed) {
      return _this._runBatch((0, _difference3.default)(all, completed), 'up');
    });
  }

• example usage

  n/a

function knex.migrate.prototype.make (name, config)

• description and source-code

  function make(name, config) {
    var _this4 = this;
  
    this.config = this.setConfig(config);
    if (!name) {
      return _bluebird2.default.reject(new Error('A name must be specified for the generated migration'));
    }
  
    return this._ensureFolder(config).then(function (val) {
      return _this4._generateStubTemplate(val);
    }).then(function (val) {
      return _this4._writeNewMigration(name, val);
    });
  }

• example usage

  n/a

function knex.migrate.prototype.rollback (config)

• description and source-code

  function rollback(config) {
    var _this2 = this;
  
    return _bluebird2.default.try(function () {
      _this2.config = _this2.setConfig(config);
      return _this2._migrationData().tap(validateMigrationList).then(function (val) {
        return _this2._getLastBatch(val);
      }).then(function (migrations) {
        return _this2._runBatch((0, _map3.default)(migrations, 'name'), 'down');
      });
    });
  }

• example usage

  ...
    } catch (err) {
      result = _bluebird2.default.reject(err);
    }
    if (result && result.then && typeof result.then === 'function') {
      result.then(function (val) {
        return transactor.commit(val);
      }).catch(function (err) {
        return transactor.rollback(err);
      });
    }
    return null;
  }).catch(function (e) {
    return _this._rejecter(e);
  });
  ...

function knex.migrate.prototype.setConfig (config)

• description and source-code

  function setConfig(config) {
    return (0, _assign3.default)({}, CONFIG_DEFAULT, this.config || {}, config);
  }

• example usage

  n/a

function knex.migrate.prototype.status (config)

• description and source-code

  function status(config) {
    this.config = this.setConfig(config);
  
    return _bluebird2.default.all([this.knex(this.config.tableName).select('*'), this._listAll()]).spread(function (db, code) {
      return db.length - code.length;
    });
  }

• example usage

  n/a

module knex.raw

function knex.raw ()

• description and source-code

  function Raw() {
    var client = arguments.length <= 0 || arguments[0] === undefined ? fakeClient : arguments[0];
  
    this.client = client;
  
    this.sql = '';
    this.bindings = [];
  
    // Todo: Deprecate
    this._wrappedBefore = undefined;
    this._wrappedAfter = undefined;
    this._debug = client && client.config && client.config.debug;
  }

• example usage

  ...
  // FunctionHelper
  // -------
  function FunctionHelper(client) {
    this.client = client;
  }
  
  FunctionHelper.prototype.now = function () {
    return this.client.raw('CURRENT_TIMESTAMP');
  };
  
  exports.default = FunctionHelper;
  module.exports = exports['default'];
  ...

function knex.raw.super_ ()

• description and source-code

  function EventEmitter() {
    EventEmitter.init.call(this);
  }

• example usage

  n/a

module knex.raw.prototype

function knex.raw.prototype.asCallback ()

• description and source-code

  asCallback = function () {
    var promise = this.then();
    return promise[method].apply(promise, arguments);
  }

• example usage

  n/a

function knex.raw.prototype.bind ()

• description and source-code

  bind = function () {
    var promise = this.then();
    return promise[method].apply(promise, arguments);
  }

• example usage

  ...
      throw error;
    });
  }),
  
  // In the case of the "schema builder" we call `queryArray`, which runs each
  // of the queries in sequence.
  queryArray: function queryArray(queries) {
    return queries.length === 1 ? this.query(queries[0]) : _bluebird2.default.bind(this
  ).return(queries).reduce(function (memo, query) {
      return this.query(query).then(function (resp) {
        memo.push(resp);
        return memo;
      });
    }, []);
  },
  ...

function knex.raw.prototype.catch ()

• description and source-code

  catch = function () {
    var promise = this.then();
    return promise[method].apply(promise, arguments);
  }

• example usage

  ...
  
  // .map over the results
  .map(function(row) {
    console.log(row);
  })
  
  // Finally, add a .catch handler for the promise chain
  .catch(function(e) {
    console.error(e);
  });
  ```
  ...

function knex.raw.prototype.connection (connection)

• description and source-code

  connection = function (connection) {
    this._connection = connection;
    return this;
  }

• example usage

  n/a

function knex.raw.prototype.debug (enabled)

• description and source-code

  debug = function (enabled) {
    this._debug = arguments.length ? enabled : true;
    return this;
  }

• example usage

  n/a

function knex.raw.prototype.delay ()

• description and source-code

  delay = function () {
    var promise = this.then();
    return promise[method].apply(promise, arguments);
  }

• example usage

  n/a

function knex.raw.prototype.ensure ()

• description and source-code

  ensure = function () {
    var promise = this.then();
    return promise[method].apply(promise, arguments);
  }

• example usage

  n/a

function knex.raw.prototype.finally ()

• description and source-code

  finally = function () {
    var promise = this.then();
    return promise[method].apply(promise, arguments);
  }

• example usage

  n/a

function knex.raw.prototype.get ()

• description and source-code

  get = function () {
    var promise = this.then();
    return promise[method].apply(promise, arguments);
  }

• example usage

  n/a

function knex.raw.prototype.map ()

• description and source-code

  map = function () {
    var promise = this.then();
    return promise[method].apply(promise, arguments);
  }

• example usage

  ...
  .then(function() {
    return knex('users')
      .join('accounts', 'users.id', 'accounts.user_id')
      .select('users.user_name as user', 'accounts.account_name as account');
  })
  
  // .map over the results
  .map(function(row) {
    console.log(row);
  })
  
  // Finally, add a .catch handler for the promise chain
  .catch(function(e) {
    console.error(e);
  });
  ...

function knex.raw.prototype.mapSeries ()

• description and source-code

  mapSeries = function () {
    var promise = this.then();
    return promise[method].apply(promise, arguments);
  }

• example usage

  n/a

function knex.raw.prototype.options (opts)

• description and source-code

  options = function (opts) {
    this._options = this._options || [];
    this._options.push((0, _clone3.default)(opts) || {});
    return this;
  }

• example usage

  n/a

function knex.raw.prototype.pipe (writable, options)

• description and source-code

  pipe = function (writable, options) {
    return this.client.runner(this).pipe(writable, options);
  }

• example usage

  ...
  // Initializes a stream.
  Target.prototype.stream = function (options) {
    return this.client.runner(this).stream(options);
  };
  
  // Initialize a stream & pipe automatically.
  Target.prototype.pipe = function (writable, options) {
    return this.client.runner(this).pipe(writable, options);
  };
  
  // Creates a method which "coerces" to a promise, by calling a
  // "then" method on the current `Target`
  (0, _each3.default)(['bind', 'catch', 'finally', 'asCallback', 'spread', '
  ;map', 'reduce', 'tap', 'thenReturn', 'return', 'yield', 'ensure'
  ;, 'reflect', 'get', 'mapSeries', 'delay'], function (method) {
    Target.prototype[method] = function () {
      var promise = this.then();
  ...

function knex.raw.prototype.reduce ()

• description and source-code

  reduce = function () {
    var promise = this.then();
    return promise[method].apply(promise, arguments);
  }

• example usage

  ...
      throw error;
    });
  }),
  
  // In the case of the "schema builder" we call `queryArray`, which runs each
  // of the queries in sequence.
  queryArray: function queryArray(queries) {
    return queries.length === 1 ? this.query(queries[0]) : _bluebird2.default.bind(this).return(queries).reduce(function (memo, query) {
      return this.query(query).then(function (resp) {
        memo.push(resp);
        return memo;
      });
    }, []);
  },
  ...

function knex.raw.prototype.reflect ()

• description and source-code

  reflect = function () {
    var promise = this.then();
    return promise[method].apply(promise, arguments);
  }

• example usage

  n/a

function knex.raw.prototype.return ()

• description and source-code

  return = function () {
    var promise = this.then();
    return promise[method].apply(promise, arguments);
  }

• example usage

  ...
      throw error;
    });
  }),
  
  // In the case of the "schema builder" we call `queryArray`, which runs each
  // of the queries in sequence.
  queryArray: function queryArray(queries) {
    return queries.length === 1 ? this.query(queries[0]) : _bluebird2.default.bind(this).return
  (queries).reduce(function (memo, query) {
      return this.query(query).then(function (resp) {
        memo.push(resp);
        return memo;
      });
    }, []);
  },
  ...

function knex.raw.prototype.set (sql, bindings)

• description and source-code

  function set(sql, bindings) {
    this.sql = sql;
    this.bindings = (0, _isObject3.default)(bindings) && !bindings.toSQL || (0, _isUndefined3.default)(bindings) ? bindings : [bindings
  ];
  
    return this;
  }

• example usage

  n/a

function knex.raw.prototype.spread ()

• description and source-code

  spread = function () {
    var promise = this.then();
    return promise[method].apply(promise, arguments);
  }

• example usage

  n/a

function knex.raw.prototype.stream (options)

• description and source-code

  stream = function (options) {
    return this.client.runner(this).stream(options);
  }

• example usage

  ...
      }
    }
    return this;
  };
  
  // Initializes a stream.
  Target.prototype.stream = function (options) {
    return this.client.runner(this).stream(options);
  };
  
  // Initialize a stream & pipe automatically.
  Target.prototype.pipe = function (writable, options) {
    return this.client.runner(this).pipe(writable, options);
  };
  ...

function knex.raw.prototype.tap ()

• description and source-code

  tap = function () {
    var promise = this.then();
    return promise[method].apply(promise, arguments);
  }

• example usage

  ...
        runner.builder.emit('error', err);
      }
      throw err;
    })
  
    // Fire a single "end" event on the builder when
    // all queries have successfully completed.
    .tap(function () {
      runner.builder.emit('end');
    });
  },
  
  
  // Stream the result set, by passing through to the dialect's streaming
  // capabilities. If the options are
  ...

function knex.raw.prototype.then ()

• description and source-code

  then = function () /* onFulfilled, onRejected */{
    var result = this.client.runner(this).run();
    return result.then.apply(result, arguments);
  }

• example usage

  ...
  .createTable('accounts', function(table) {
    table.increments('id');
    table.string('account_name');
    table.integer('user_id').unsigned().references('users.id');
  })
  
  // Then query the table...
  .then(function() {
    return knex.insert({user_name: 'Tim'}).into('users');
  })
  
  // ...and using the insert id, insert into the other table.
  .then(function(rows) {
    return knex.table('accounts').insert({account_name: 'knex', user_id: rows[0]});
  })
  ...

function knex.raw.prototype.thenReturn ()

• description and source-code

  thenReturn = function () {
    var promise = this.then();
    return promise[method].apply(promise, arguments);
  }

• example usage

  n/a

function knex.raw.prototype.timeout (ms)

• description and source-code

  function timeout(ms) {
    var _ref = arguments.length <= 1 || arguments[1] === undefined ? {} : arguments[1];
  
    var cancel = _ref.cancel;
  
    if ((0, _isNumber3.default)(ms) && ms > 0) {
      this._timeout = ms;
      if (cancel) {
        this.client.assertCanCancelQuery();
        this._cancelOnTimeout = true;
      }
    }
    return this;
  }

• example usage

  ...
  var _this = this;
  
  this.builder.emit('query', (0, _assign3.default)({ __knexUid: this.connection.__knexUid }, obj));
  var runner = this;
  var queryPromise = this.client.query(this.connection, obj);
  
  if (obj.timeout) {
    queryPromise = queryPromise.timeout(obj.timeout);
  }
  
  return queryPromise.then(function (resp) {
    var processedResponse = _this.client.processResponse(resp, runner);
    _this.builder.emit('query-response', processedResponse, (0, _assign3.default)({ __knexUid: _this.connection.__knexUid
   }, obj), _this.builder);
    _this.client.emit('query-response', processedResponse, (0, _assign3.default)({ __knexUid: _this.connection.__knexUid
   }, obj), _this.builder);
    return processedResponse;
  ...

function knex.raw.prototype.toQuery (tz)

• description and source-code

  toQuery = function (tz) {
    var _this = this;
  
    var data = this.toSQL(this._method, tz);
    if (!(0, _isArray3.default)(data)) data = [data];
    return (0, _map3.default)(data, function (statement) {
      return _this.client._formatQuery(statement.sql, statement.bindings, tz);
    }).join(';\n');
  }

• example usage

  ...
    this._wrappedAfter = after;
    return this;
  },
  
  
  // Calls `toString` on the Knex object.
  toString: function toString() {
    return this.toQuery();
  },
  
  
  // Returns the raw sql for the query.
  toSQL: function toSQL(method, tz) {
    var obj = void 0;
    var formatter = this.client.formatter();
  ...

function knex.raw.prototype.toSQL (method, tz)

• description and source-code

  function toSQL(method, tz) {
    var obj = void 0;
    var formatter = this.client.formatter();
  
    if (Array.isArray(this.bindings)) {
      obj = replaceRawArrBindings(this, formatter);
    } else if (this.bindings && (0, _isPlainObject3.default)(this.bindings)) {
      obj = replaceKeyBindings(this, formatter);
    } else {
      obj = {
        method: 'raw',
        sql: this.sql,
        bindings: (0, _isUndefined3.default)(this.bindings) ? [] : [this.bindings]
      };
    }
  
    if (this._wrappedBefore) {
      obj.sql = this._wrappedBefore + obj.sql;
    }
    if (this._wrappedAfter) {
      obj.sql = obj.sql + this._wrappedAfter;
    }
  
    obj.options = (0, _reduce3.default)(this._options, _assign3.default, {});
  
    if (this._timeout) {
      obj.timeout = this._timeout;
      if (this._cancelOnTimeout) {
        obj.cancelOnTimeout = this._cancelOnTimeout;
      }
    }
  
    obj.bindings = obj.bindings || [];
    if (helpers.containsUndefined(obj.bindings)) {
      debugBindings(obj.bindings);
      throw new Error('Undefined binding(s) detected when compiling RAW query: ' + obj.sql);
    }
  
    obj.__knexQueryUid = _uuid2.default.v4();
  
    return obj;
  }

• example usage

  ...
    }
    return this.unwrapRaw(value, true) || '?';
  };
  
  Formatter.prototype.unwrapRaw = function unwrapRaw(value, isParameter) {
    var query = void 0;
    if (value instanceof _builder2.default) {
      query = this.client.queryCompiler(value).toSQL();
      if (query.bindings) {
        this.bindings = this.bindings.concat(query.bindings);
      }
      return this.outputQuery(query, isParameter);
    }
    if (value instanceof _raw2.default) {
      value.client = this.client;
  ...

function knex.raw.prototype.toString ()

• description and source-code

  function toString() {
    return this.toQuery();
  }

• example usage

  n/a

function knex.raw.prototype.transacting (t)

• description and source-code

  transacting = function (t) {
    if (t && t.client) {
      if (!t.client.transacting) {
        helpers.warn('Invalid transaction value: ' + t.client);
      } else {
        this.client = t.client;
      }
    }
    return this;
  }

• example usage

  n/a

function knex.raw.prototype.wrap (before, after)

• description and source-code

  function wrap(before, after) {
    this._wrappedBefore = before;
    this._wrappedAfter = after;
    return this;
  }

• example usage

  ...
  
  Formatter.prototype.columnize = function columnize(target) {
    var columns = typeof target === 'string' ? [target] : target;
    var str = '',
        i = -1;
    while (++i < columns.length) {
      if (i > 0) str += ', ';
      str += this.wrap(columns[i]);
    }
    return str;
  };
  
  // Turns a list of values into a list of ?'s, joining them with commas unless
  // a "joining" value is specified (e.g. ' and ')
  ...

function knex.raw.prototype.yield ()

• description and source-code

  yield = function () {
    var promise = this.then();
    return promise[method].apply(promise, arguments);
  }

• example usage

  n/a

module knex.runner

function knex.runner (client, builder)

• description and source-code

  function Runner(client, builder) {
    this.client = client;
    this.builder = builder;
    this.queries = [];
  
    // The "connection" object is set on the runner when
    // "run" is called.
    this.connection = void 0;
  }

• example usage

  ...
    return (0, _map3.default)(data, function (statement) {
      return _this.client._formatQuery(statement.sql, statement.bindings, tz);
    }).join(';\n');
  };
  
  // Create a new instance of the `Runner`, passing in the current object.
  Target.prototype.then = function () /* onFulfilled, onRejected */{
    var result = this.client.runner(this).run();
    return result.then.apply(result, arguments);
  };
  
  // Add additional "options" to the builder. Typically used for client specific
  // items, like the `mysql` and `sqlite3` drivers.
  Target.prototype.options = function (opts) {
    this._options = this._options || [];
  ...

module knex.runner.prototype

function knex.runner.prototype.ensureConnection ()

• description and source-code

  function ensureConnection() {
    var _this2 = this;
  
    return _bluebird2.default.try(function () {
      return _this2.connection || new _bluebird2.default(function (resolver, rejecter) {
        // need to return promise or null from handler to prevent warning from bluebird
        return _this2.client.acquireConnection().then(resolver).catch(_bluebird2.default.TimeoutError, function (error) {
          if (_this2.builder) {
            error.sql = _this2.builder.sql;
            error.bindings = _this2.builder.bindings;
          }
          throw error;
        }).catch(rejecter);
      });
    }).disposer(function () {
      // need to return promise or null from handler to prevent warning from bluebird
      return _this2.client.releaseConnection(_this2.connection);
    });
  }

• example usage

  ...
  (0, _assign3.default)(Runner.prototype, {
  
    // "Run" the target, calling "toSQL" on the builder, returning
    // an object or array of queries to run, each of which are run on
    // a single connection.
    run: function run() {
      var runner = this;
      return _bluebird2.default.using(this.ensureConnection(), function (connection) {
  runner.connection = connection;
  
  runner.client.emit('start', runner.builder);
  runner.builder.emit('start', runner.builder);
  var sql = runner.builder.toSQL();
  
  if (runner.builder._debug) {
  ...

function knex.runner.prototype.pipe (writable, options)

• description and source-code

  function pipe(writable, options) {
    return this.stream(options).pipe(writable);
  }

• example usage

  ...
  // Initializes a stream.
  Target.prototype.stream = function (options) {
    return this.client.runner(this).stream(options);
  };
  
  // Initialize a stream & pipe automatically.
  Target.prototype.pipe = function (writable, options) {
    return this.client.runner(this).pipe(writable, options);
  };
  
  // Creates a method which "coerces" to a promise, by calling a
  // "then" method on the current `Target`
  (0, _each3.default)(['bind', 'catch', 'finally', 'asCallback', 'spread', '
  ;map', 'reduce', 'tap', 'thenReturn', 'return', 'yield', 'ensure'
  ;, 'reflect', 'get', 'mapSeries', 'delay'], function (method) {
    Target.prototype[method] = function () {
      var promise = this.then();
  ...

function knex.runner.prototype.query ()

• description and source-code

  query = function () {
      var ret = new Promise(INTERNAL);
      ret._captureStackTrace();
      ret._pushContext();
      var value = tryCatch(fn).apply(this, arguments);
      var promiseCreated = ret._popContext();
      debug.checkForgottenReturns(
          value, promiseCreated, "Promise.method", ret);
      ret._resolveFromSyncValue(value);
      return ret;
  }

• example usage

  ...
    if (runner.builder._debug) {
      helpers.debugLog(sql);
    }
  
    if ((0, _isArray3.default)(sql)) {
      return runner.queryArray(sql);
    }
    return runner.query(sql);
  })
  
  // If there are any "error" listeners, we fire an error event
  // and then re-throw the error to be eventually handled by
  // the promise chain. Useful if you're wrapping in a custom `Promise`.
  .catch(function (err) {
    if (runner.builder._events && runner.builder._events.error) {
  ...

function knex.runner.prototype.queryArray (queries)

• description and source-code

  function queryArray(queries) {
    return queries.length === 1 ? this.query(queries[0]) : _bluebird2.default.bind(this).return(queries).reduce(function (memo, query
  ) {
      return this.query(query).then(function (resp) {
        memo.push(resp);
        return memo;
      });
    }, []);
  }

• example usage

  ...
    var sql = runner.builder.toSQL();
  
    if (runner.builder._debug) {
      helpers.debugLog(sql);
    }
  
    if ((0, _isArray3.default)(sql)) {
      return runner.queryArray(sql);
    }
    return runner.query(sql);
  })
  
  // If there are any "error" listeners, we fire an error event
  // and then re-throw the error to be eventually handled by
  // the promise chain. Useful if you're wrapping in a custom `Promise`.
  ...

function knex.runner.prototype.run ()

• description and source-code

  function run() {
    var runner = this;
    return _bluebird2.default.using(this.ensureConnection(), function (connection) {
      runner.connection = connection;
  
      runner.client.emit('start', runner.builder);
      runner.builder.emit('start', runner.builder);
      var sql = runner.builder.toSQL();
  
      if (runner.builder._debug) {
        helpers.debugLog(sql);
      }
  
      if ((0, _isArray3.default)(sql)) {
        return runner.queryArray(sql);
      }
      return runner.query(sql);
    })
  
    // If there are any "error" listeners, we fire an error event
    // and then re-throw the error to be eventually handled by
    // the promise chain. Useful if you're wrapping in a custom `Promise`.
    .catch(function (err) {
      if (runner.builder._events && runner.builder._events.error) {
        runner.builder.emit('error', err);
      }
      throw err;
    })
  
    // Fire a single "end" event on the builder when
    // all queries have successfully completed.
    .tap(function () {
      runner.builder.emit('end');
    });
  }

• example usage

  ...
    return (0, _map3.default)(data, function (statement) {
      return _this.client._formatQuery(statement.sql, statement.bindings, tz);
    }).join(';\n');
  };
  
  // Create a new instance of the `Runner`, passing in the current object.
  Target.prototype.then = function () /* onFulfilled, onRejected */{
    var result = this.client.runner(this).run();
    return result.then.apply(result, arguments);
  };
  
  // Add additional "options" to the builder. Typically used for client specific
  // items, like the `mysql` and `sqlite3` drivers.
  Target.prototype.options = function (opts) {
    this._options = this._options || [];
  ...

function knex.runner.prototype.stream (options, handler)

• description and source-code

  function stream(options, handler) {
  
    // If we specify stream(handler).then(...
    if (arguments.length === 1) {
      if (typeof options === 'function') {
        handler = options;
        options = {};
      }
    }
  
    // Determines whether we emit an error or throw here.
    var hasHandler = typeof handler === 'function';
  
    // Lazy-load the "PassThrough" dependency.
    PassThrough = PassThrough || require('readable-stream').PassThrough;
  
    var runner = this;
    var stream = new PassThrough({ objectMode: true });
    var promise = _bluebird2.default.using(this.ensureConnection(), function (connection) {
      runner.connection = connection;
      var sql = runner.builder.toSQL();
      var err = new Error('The stream may only be used with a single query statement.');
      if ((0, _isArray3.default)(sql)) {
        if (hasHandler) throw err;
        stream.emit('error', err);
      }
      return runner.client.stream(runner.connection, sql, stream, options);
    });
  
    // If a function is passed to handle the stream, send the stream
    // there and return the promise, otherwise just return the stream
    // and the promise will take care of itsself.
    if (hasHandler) {
      handler(stream);
      return promise;
    }
  
    // This promise is unreachable since no handler was given, so noop any
    // exceptions. Errors should be handled in the stream's 'error' event.
    promise.catch(_noop3.default);
    return stream;
  }

• example usage

  ...
      }
    }
    return this;
  };
  
  // Initializes a stream.
  Target.prototype.stream = function (options) {
    return this.client.runner(this).stream(options);
  };
  
  // Initialize a stream & pipe automatically.
  Target.prototype.pipe = function (writable, options) {
    return this.client.runner(this).pipe(writable, options);
  };
  ...

module knex.seed

function knex.seed (knex)

• description and source-code

  function Seeder(knex) {
    this.knex = knex;
    this.config = this.setConfig(knex.client.config.seeds);
  }

• example usage

  n/a

module knex.seed.prototype

function knex.seed.prototype._absoluteConfigDir ()

• description and source-code

  _absoluteConfigDir = function () {
    return _path2.default.resolve(process.cwd(), this.config.directory);
  }

• example usage

  n/a

function knex.seed.prototype._ensureFolder ()

• description and source-code

  _ensureFolder = function () {
    var dir = this._absoluteConfigDir();
    return _bluebird2.default.promisify(_fs2.default.stat, { context: _fs2.default })(dir).catch(function () {
      return _bluebird2.default.promisify(_mkdirp2.default)(dir);
    });
  }

• example usage

  n/a

function knex.seed.prototype._generateStubTemplate ()

• description and source-code

  _generateStubTemplate = function () {
    var stubPath = this.config.stub || _path2.default.join(__dirname, 'stub', this.config.extension + '.stub');
    return _bluebird2.default.promisify(_fs2.default.readFile, { context: _fs2.default })(stubPath).then(function (stub) {
      return (0, _template3.default)(stub.toString(), { variable: 'd' });
    });
  }

• example usage

  n/a

function knex.seed.prototype._listAll ()

• description and source-code

  _listAll = function () {
      var ret = new Promise(INTERNAL);
      ret._captureStackTrace();
      ret._pushContext();
      var value = tryCatch(fn).apply(this, arguments);
      var promiseCreated = ret._popContext();
      debug.checkForgottenReturns(
          value, promiseCreated, "Promise.method", ret);
      ret._resolveFromSyncValue(value);
      return ret;
  }

• example usage

  n/a

function knex.seed.prototype._runSeeds (seeds)

• description and source-code

  _runSeeds = function (seeds) {
    return _bluebird2.default.all((0, _map3.default)(seeds, (0, _bind3.default)(this._validateSeedStructure, this))).bind(this).then
  (function (seeds) {
      return _bluebird2.default.bind(this).then(function () {
        return this._waterfallBatch(seeds);
      });
    });
  }

• example usage

  n/a

function knex.seed.prototype._seedData ()

• description and source-code

  _seedData = function () {
    return _bluebird2.default.join(this._listAll());
  }

• example usage

  n/a

function knex.seed.prototype._validateSeedStructure (name)

• description and source-code

  _validateSeedStructure = function (name) {
    var seed = require(_path2.default.join(this._absoluteConfigDir(), name));
    if (typeof seed.seed !== 'function') {
      throw new Error('Invalid seed file: ' + name + ' must have a seed function');
    }
    return name;
  }

• example usage

  n/a

function knex.seed.prototype._waterfallBatch (seeds)

• description and source-code

  _waterfallBatch = function (seeds) {
    var knex = this.knex;
  
    var seedDirectory = this._absoluteConfigDir();
    var current = _bluebird2.default.bind({ failed: false, failedOn: 0 });
    var log = [];
    (0, _each3.default)(seeds, function (seed) {
      var name = _path2.default.join(seedDirectory, seed);
      seed = require(name);
  
      // Run each seed file.
      current = current.then(function () {
        return seed.seed(knex, _bluebird2.default);
      }).then(function () {
        log.push(name);
      });
    });
  
    return current.thenReturn([log]);
  }

• example usage

  n/a

function knex.seed.prototype._writeNewSeed (name)

• description and source-code

  _writeNewSeed = function (name) {
    var config = this.config;
  
    var dir = this._absoluteConfigDir();
    return function (tmpl) {
      if (name[0] === '-') name = name.slice(1);
      var filename = name + '.' + config.extension;
      return _bluebird2.default.promisify(_fs2.default.writeFile, { context: _fs2.default })(_path2.default.join(dir, filename), tmpl
  (config.variables || {})).return(_path2.default.join(dir, filename));
    };
  }

• example usage

  n/a

function knex.seed.prototype.make (name, config)

• description and source-code

  make = function (name, config) {
    this.config = this.setConfig(config);
    if (!name) _bluebird2.default.rejected(new Error('A name must be specified for the generated seed'));
    return this._ensureFolder(config).bind(this).then(this._generateStubTemplate).then(this._writeNewSeed(name));
  }

• example usage

  n/a

function knex.seed.prototype.run ()

• description and source-code

  run = function () {
      var ret = new Promise(INTERNAL);
      ret._captureStackTrace();
      ret._pushContext();
      var value = tryCatch(fn).apply(this, arguments);
      var promiseCreated = ret._popContext();
      debug.checkForgottenReturns(
          value, promiseCreated, "Promise.method", ret);
      ret._resolveFromSyncValue(value);
      return ret;
  }

• example usage

  ...
    return (0, _map3.default)(data, function (statement) {
      return _this.client._formatQuery(statement.sql, statement.bindings, tz);
    }).join(';\n');
  };
  
  // Create a new instance of the `Runner`, passing in the current object.
  Target.prototype.then = function () /* onFulfilled, onRejected */{
    var result = this.client.runner(this).run();
    return result.then.apply(result, arguments);
  };
  
  // Add additional "options" to the builder. Typically used for client specific
  // items, like the `mysql` and `sqlite3` drivers.
  Target.prototype.options = function (opts) {
    this._options = this._options || [];
  ...

function knex.seed.prototype.setConfig (config)

• description and source-code

  setConfig = function (config) {
    return (0, _extend3.default)({
      extension: 'js',
      directory: './seeds'
    }, this.config || {}, config);
  }

• example usage

  n/a

module knex.transaction

function knex.transaction (client, container, config, outerTx)

• description and source-code

  function Transaction(client, container, config, outerTx) {
    (0, _classCallCheck3.default)(this, Transaction);
  
    var _this = (0, _possibleConstructorReturn3.default)(this, _EventEmitter.call(this));
  
    var txid = _this.txid = (0, _uniqueId3.default)('trx');
  
    _this.client = client;
    _this.outerTx = outerTx;
    _this.trxClient = undefined;
    _this._debug = client.config && client.config.debug;
  
    debug('%s: Starting %s transaction', txid, outerTx ? 'nested' : 'top level');
  
    _this._promise = _bluebird2.default.using(_this.acquireConnection(client, config, txid), function (connection) {
  
      var trxClient = _this.trxClient = makeTxClient(_this, client, connection);
      var init = client.transacting ? _this.savepoint(connection) : _this.begin(connection);
  
      init.then(function () {
        return makeTransactor(_this, connection, trxClient);
      }).then(function (transactor) {
        // If we've returned a "thenable" from the transaction container, assume
        // the rollback and commit are chained to this object's success / failure.
        // Directly thrown errors are treated as automatic rollbacks.
        var result = void 0;
        try {
          result = container(transactor);
        } catch (err) {
          result = _bluebird2.default.reject(err);
        }
        if (result && result.then && typeof result.then === 'function') {
          result.then(function (val) {
            return transactor.commit(val);
          }).catch(function (err) {
            return transactor.rollback(err);
          });
        }
        return null;
      }).catch(function (e) {
        return _this._rejecter(e);
      });
  
      return new _bluebird2.default(function (resolver, rejecter) {
        _this._resolver = resolver;
        _this._rejecter = rejecter;
      });
    });
  
    _this._completed = false;
  
    // If there's a wrapping transaction, we need to wait for any older sibling
    // transactions to settle (commit or rollback) before we can start, and we
    // need to register ourselves with the parent transaction so any younger
    // siblings can wait for us to complete before they can start.
    _this._previousSibling = _bluebird2.default.resolve(true);
    if (outerTx) {
      if (outerTx._lastChild) _this._previousSibling = outerTx._lastChild;
      outerTx._lastChild = _this._promise;
    }
    return _this;
  }

• example usage

  ...
  
  exports.default = Transaction;
  function makeTransactor(trx, connection, trxClient) {
  
  var transactor = (0, _makeKnex2.default)(trxClient);
  
  transactor.transaction = function (container, options) {
    return trxClient.transaction(container, options, trx);
  };
  transactor.savepoint = function (container, options) {
    return transactor.transaction(container, options);
  };
  
  if (trx.client.transacting) {
    transactor.commit = function (value) {
  ...

module knex.transaction.prototype

function knex.transaction.prototype.acquireConnection (client, config, txid)

• description and source-code

  function acquireConnection(client, config, txid) {
    var configConnection = config && config.connection;
    return _bluebird2.default.try(function () {
      return configConnection || client.acquireConnection();
    }).disposer(function (connection) {
      if (!configConnection) {
        debug('%s: releasing connection', txid);
        client.releaseConnection(connection);
      } else {
        debug('%s: not releasing external connection', txid);
      }
    });
  }

• example usage

  ...
    // Check whether there's a transaction flag, and that it has a connection.
    ensureConnection: function ensureConnection() {
  var _this2 = this;
  
  return _bluebird2.default.try(function () {
    return _this2.connection || new _bluebird2.default(function (resolver, rejecter) {
      // need to return promise or null from handler to prevent warning from bluebird
      return _this2.client.acquireConnection().then(resolver).catch(_bluebird2.default.
  TimeoutError, function (error) {
        if (_this2.builder) {
          error.sql = _this2.builder.sql;
          error.bindings = _this2.builder.bindings;
        }
        throw error;
      }).catch(rejecter);
    });
  ...

function knex.transaction.prototype.asCallback ()

• description and source-code

  asCallback = function () {
    return this._promise = this._promise[method].apply(this._promise, arguments);
  }

• example usage

  n/a

function knex.transaction.prototype.begin (conn)

• description and source-code

  function begin(conn) {
    return this.query(conn, 'BEGIN;');
  }

• example usage

  ...
      _this._debug = client.config && client.config.debug;
  
      debug('%s: Starting %s transaction', txid, outerTx ? 'nested' : 'top level');
  
      _this._promise = _bluebird2.default.using(_this.acquireConnection(client, config, txid), function (connection) {
  
  var trxClient = _this.trxClient = makeTxClient(_this, client, connection);
  var init = client.transacting ? _this.savepoint(connection) : _this.begin(connection);
  
  init.then(function () {
    return makeTransactor(_this, connection, trxClient);
  }).then(function (transactor) {
    // If we've returned a "thenable" from the transaction container, assume
    // the rollback and commit are chained to this object's success / failure.
    // Directly thrown errors are treated as automatic rollbacks.
  ...

function knex.transaction.prototype.bind ()

• description and source-code

  bind = function () {
    return this._promise = this._promise[method].apply(this._promise, arguments);
  }

• example usage

  ...
      throw error;
    });
  }),
  
  // In the case of the "schema builder" we call `queryArray`, which runs each
  // of the queries in sequence.
  queryArray: function queryArray(queries) {
    return queries.length === 1 ? this.query(queries[0]) : _bluebird2.default.bind(this
  ).return(queries).reduce(function (memo, query) {
      return this.query(query).then(function (resp) {
        memo.push(resp);
        return memo;
      });
    }, []);
  },
  ...

function knex.transaction.prototype.catch ()

• description and source-code

  catch = function () {
    return this._promise = this._promise[method].apply(this._promise, arguments);
  }

• example usage

  ...
  
  // .map over the results
  .map(function(row) {
    console.log(row);
  })
  
  // Finally, add a .catch handler for the promise chain
  .catch(function(e) {
    console.error(e);
  });
  ```
  ...

function knex.transaction.prototype.commit (conn, value)

• description and source-code

  function commit(conn, value) {
    return this.query(conn, 'COMMIT;', 1, value);
  }

• example usage

  ...
    try {
      result = container(transactor);
    } catch (err) {
      result = _bluebird2.default.reject(err);
    }
    if (result && result.then && typeof result.then === 'function') {
      result.then(function (val) {
        return transactor.commit(val);
      }).catch(function (err) {
        return transactor.rollback(err);
      });
    }
    return null;
  }).catch(function (e) {
    return _this._rejecter(e);
  ...

function knex.transaction.prototype.debug (enabled)

• description and source-code

  function debug(enabled) {
    this._debug = arguments.length ? enabled : true;
    return this;
  }

• example usage

  n/a

function knex.transaction.prototype.delay ()

• description and source-code

  delay = function () {
    return this._promise = this._promise[method].apply(this._promise, arguments);
  }

• example usage

  n/a

function knex.transaction.prototype.ensure ()

• description and source-code

  ensure = function () {
    return this._promise = this._promise[method].apply(this._promise, arguments);
  }

• example usage

  n/a

function knex.transaction.prototype.exec ()

• description and source-code

  exec = function () {
    return this._promise = this._promise[method].apply(this._promise, arguments);
  }

• example usage

  n/a

function knex.transaction.prototype.finally ()

• description and source-code

  finally = function () {
    return this._promise = this._promise[method].apply(this._promise, arguments);
  }

• example usage

  n/a

function knex.transaction.prototype.get ()

• description and source-code

  get = function () {
    return this._promise = this._promise[method].apply(this._promise, arguments);
  }

• example usage

  n/a

function knex.transaction.prototype.isCompleted ()

• description and source-code

  function isCompleted() {
    return this._completed || this.outerTx && this.outerTx.isCompleted() || false;
  }

• example usage

  ...
      if (outerTx._lastChild) _this._previousSibling = outerTx._lastChild;
      outerTx._lastChild = _this._promise;
    }
    return _this;
  }
  
  Transaction.prototype.isCompleted = function isCompleted() {
    return this._completed || this.outerTx && this.outerTx.isCompleted() || false
  ;
  };
  
  Transaction.prototype.begin = function begin(conn) {
    return this.query(conn, 'BEGIN;');
  };
  
  Transaction.prototype.savepoint = function savepoint(conn) {
  ...

function knex.transaction.prototype.map ()

• description and source-code

  map = function () {
    return this._promise = this._promise[method].apply(this._promise, arguments);
  }

• example usage

  ...
  .then(function() {
    return knex('users')
      .join('accounts', 'users.id', 'accounts.user_id')
      .select('users.user_name as user', 'accounts.account_name as account');
  })
  
  // .map over the results
  .map(function(row) {
    console.log(row);
  })
  
  // Finally, add a .catch handler for the promise chain
  .catch(function(e) {
    console.error(e);
  });
  ...

function knex.transaction.prototype.mapSeries ()

• description and source-code

  mapSeries = function () {
    return this._promise = this._promise[method].apply(this._promise, arguments);
  }

• example usage

  n/a

function knex.transaction.prototype.query (conn, sql, status, value)

• description and source-code

  function query(conn, sql, status, value) {
    var _this4 = this;
  
    var q = this.trxClient.query(conn, sql).catch(function (err) {
      status = 2;
      value = err;
      _this4._completed = true;
      debug('%s error running transaction query', _this4.txid);
    }).tap(function () {
      if (status === 1) {
        _this4._resolver(value);
      }
      if (status === 2) {
        if ((0, _isUndefined3.default)(value)) {
          value = new Error('Transaction rejected with non-error: ' + value);
        }
        _this4._rejecter(value);
      }
    });
    if (status === 1 || status === 2) {
      this._completed = true;
    }
    return q;
  }

• example usage

  ...
    if (runner.builder._debug) {
      helpers.debugLog(sql);
    }
  
    if ((0, _isArray3.default)(sql)) {
      return runner.queryArray(sql);
    }
    return runner.query(sql);
  })
  
  // If there are any "error" listeners, we fire an error event
  // and then re-throw the error to be eventually handled by
  // the promise chain. Useful if you're wrapping in a custom `Promise`.
  .catch(function (err) {
    if (runner.builder._events && runner.builder._events.error) {
  ...

function knex.transaction.prototype.reduce ()

• description and source-code

  reduce = function () {
    return this._promise = this._promise[method].apply(this._promise, arguments);
  }

• example usage

  ...
      throw error;
    });
  }),
  
  // In the case of the "schema builder" we call `queryArray`, which runs each
  // of the queries in sequence.
  queryArray: function queryArray(queries) {
    return queries.length === 1 ? this.query(queries[0]) : _bluebird2.default.bind(this).return(queries).reduce(function (memo, query) {
      return this.query(query).then(function (resp) {
        memo.push(resp);
        return memo;
      });
    }, []);
  },
  ...

function knex.transaction.prototype.reflect ()

• description and source-code

  reflect = function () {
    return this._promise = this._promise[method].apply(this._promise, arguments);
  }

• example usage

  n/a

function knex.transaction.prototype.release (conn, value)

• description and source-code

  function release(conn, value) {
    return this.query(conn, 'RELEASE SAVEPOINT ' + this.txid + ';', 1, value);
  }

• example usage

  ...
  };
  transactor.savepoint = function (container, options) {
    return transactor.transaction(container, options);
  };
  
  if (trx.client.transacting) {
    transactor.commit = function (value) {
      return trx.release(connection, value);
    };
    transactor.rollback = function (error) {
      return trx.rollbackTo(connection, error);
    };
  } else {
    transactor.commit = function (value) {
      return trx.commit(connection, value);
  ...

function knex.transaction.prototype.return ()

• description and source-code

  return = function () {
    return this._promise = this._promise[method].apply(this._promise, arguments);
  }

• example usage

  ...
      throw error;
    });
  }),
  
  // In the case of the "schema builder" we call `queryArray`, which runs each
  // of the queries in sequence.
  queryArray: function queryArray(queries) {
    return queries.length === 1 ? this.query(queries[0]) : _bluebird2.default.bind(this).return
  (queries).reduce(function (memo, query) {
      return this.query(query).then(function (resp) {
        memo.push(resp);
        return memo;
      });
    }, []);
  },
  ...

function knex.transaction.prototype.rollback (conn, error)

• description and source-code

  function rollback(conn, error) {
    var _this2 = this;
  
    return this.query(conn, 'ROLLBACK;', 2, error).timeout(5000).catch(_bluebird2.default.TimeoutError, function () {
      _this2._resolver();
    });
  }

• example usage

  ...
    } catch (err) {
      result = _bluebird2.default.reject(err);
    }
    if (result && result.then && typeof result.then === 'function') {
      result.then(function (val) {
        return transactor.commit(val);
      }).catch(function (err) {
        return transactor.rollback(err);
      });
    }
    return null;
  }).catch(function (e) {
    return _this._rejecter(e);
  });
  ...

function knex.transaction.prototype.rollbackTo (conn, error)

• description and source-code

  function rollbackTo(conn, error) {
    var _this3 = this;
  
    return this.query(conn, 'ROLLBACK TO SAVEPOINT ' + this.txid, 2, error).timeout(5000).catch(_bluebird2.default.TimeoutError, function
   () {
      _this3._resolver();
    });
  }

• example usage

  ...
  };
  
  if (trx.client.transacting) {
    transactor.commit = function (value) {
      return trx.release(connection, value);
    };
    transactor.rollback = function (error) {
      return trx.rollbackTo(connection, error);
    };
  } else {
    transactor.commit = function (value) {
      return trx.commit(connection, value);
    };
    transactor.rollback = function (error) {
      return trx.rollback(connection, error);
  ...

function knex.transaction.prototype.savepoint (conn)

• description and source-code

  function savepoint(conn) {
    return this.query(conn, 'SAVEPOINT ' + this.txid + ';');
  }

• example usage

  ...
      _this._debug = client.config && client.config.debug;
  
      debug('%s: Starting %s transaction', txid, outerTx ? 'nested' : 'top level');
  
      _this._promise = _bluebird2.default.using(_this.acquireConnection(client, config, txid), function (connection) {
  
  var trxClient = _this.trxClient = makeTxClient(_this, client, connection);
  var init = client.transacting ? _this.savepoint(connection) : _this.begin(connection);
  
  init.then(function () {
    return makeTransactor(_this, connection, trxClient);
  }).then(function (transactor) {
    // If we've returned a "thenable" from the transaction container, assume
    // the rollback and commit are chained to this object's success / failure.
    // Directly thrown errors are treated as automatic rollbacks.
  ...

function knex.transaction.prototype.spread ()

• description and source-code

  spread = function () {
    return this._promise = this._promise[method].apply(this._promise, arguments);
  }

• example usage

  n/a

function knex.transaction.prototype.tap ()

• description and source-code

  tap = function () {
    return this._promise = this._promise[method].apply(this._promise, arguments);
  }

• example usage

  ...
        runner.builder.emit('error', err);
      }
      throw err;
    })
  
    // Fire a single "end" event on the builder when
    // all queries have successfully completed.
    .tap(function () {
      runner.builder.emit('end');
    });
  },
  
  
  // Stream the result set, by passing through to the dialect's streaming
  // capabilities. If the options are
  ...

function knex.transaction.prototype.then ()

• description and source-code

  then = function () {
    return this._promise = this._promise[method].apply(this._promise, arguments);
  }

• example usage

  ...
  .createTable('accounts', function(table) {
    table.increments('id');
    table.string('account_name');
    table.integer('user_id').unsigned().references('users.id');
  })
  
  // Then query the table...
  .then(function() {
    return knex.insert({user_name: 'Tim'}).into('users');
  })
  
  // ...and using the insert id, insert into the other table.
  .then(function(rows) {
    return knex.table('accounts').insert({account_name: 'knex', user_id: rows[0]});
  })
  ...

function knex.transaction.prototype.thenReturn ()

• description and source-code

  thenReturn = function () {
    return this._promise = this._promise[method].apply(this._promise, arguments);
  }

• example usage

  n/a

function knex.transaction.prototype.yield ()

• description and source-code

  yield = function () {
    return this._promise = this._promise[method].apply(this._promise, arguments);
  }

• example usage

  n/a