knex/clients/server/sqlite3.js

// SQLite3
// -------

// All of the "when.js" promise components needed in this module.
var when   = require('when');
var nodefn = require('when/node/function');

// Other dependencies, including the `sqlite3` library,
// which needs to be added as a dependency to the project
// using this database.
var _       = require('underscore');
var sqlite3 = require('sqlite3');

// All other local project modules needed in this scope.
var SQLite3Base     = require('../base/sqlite3');
var ServerBase      = require('./base').ServerBase;
var Builder         = require('../../lib/builder').Builder;
var Transaction     = require('../../lib/transaction').Transaction;
var SchemaInterface = require('../../lib/schemainterface').SchemaInterface;
var Helpers         = require('../../lib/helpers').Helpers;

// Constructor for the SQLite3Client.
var SQLite3Client = exports.Client = ServerBase.extend({

  dialect: 'sqlite3',

  initialize: function() {},

  runQuery: function(connection, sql, bindings, builder) {
    if (!connection) throw new Error('No database connection exists for the query');
    if (sql === '__rename_column__') {
      return this.ddl(connection, sql, bindings, builder);
    }
    var method = (builder.type === 'insert' ||
      builder.type === 'update' || builder.type === 'delete') ? 'run' : 'all';
    // Call the querystring and then release the client
    var dfd = when.defer();
    connection[method](sql, bindings, function(err, resp) {
      if (err) return dfd.reject(err);
      // We need the context here, because it has the "this.lastID" or "this.changes"
      return dfd.resolve([resp, this]);
    });
    return dfd.promise;
  },

  poolDefaults: {
    max: 1,
    min: 1,
    destroy: function(client) { client.close(); }
  },

  ddl: function(connection, sql, bindings, builder) {
    var client = this;
    return nodefn.call(connection.run.bind(connection), 'begin transaction;').then(function() {
      var transaction  = new Transaction({client: client});
      var containerObj = transaction.getContainerObject(connection);
      return transaction.initiateDeferred(function(trx) {
        client.alterSchema.call(client, builder, trx);
      })(containerObj);
    });
  },

  getRawConnection: function() {
    var dfd = when.defer();
    var db = new sqlite3.Database(this.connectionSettings.filename, function(err) {
      if (err) return dfd.reject(err);
      dfd.resolve(db);
    });
    return dfd.promise;
  },

  // Begins a transaction statement on the instance,
  // resolving with the connection of the current transaction.
  startTransaction: function(connection) {
    return this.getConnection().tap(function(connection) {
      return nodefn.call(connection.run.bind(connection), 'begin transaction;', []);
    });
  },

  // Finishes the transaction statement on the instance.
  finishTransaction: function(type, transaction, msg) {
    var client = this;
    var dfd    = transaction.dfd;
    nodefn.call(transaction.connection.run.bind(transaction.connection), type + ';', []).then(function(resp) {
      if (type === 'commit') dfd.resolve(msg || resp);
      if (type === 'rollback') dfd.reject(msg || resp);
    }, function (err) {
      dfd.reject(err);
    }).ensure(function() {
      return client.releaseConnection(transaction.connection).tap(function() {
        transaction.connection = null;
      });
    });
  },

  // This needs to be refactored... badly.
  alterSchema: function(builder, trx) {
    var connection = trx.connection;
    var currentCol, command;

    return when.all([
      nodefn.call(connection.all.bind(connection), 'PRAGMA table_info(' + builder.table + ')', []),
      nodefn.call(connection.all.bind(connection), 'SELECT name, sql FROM sqlite_master WHERE type="table" AND name="' + builder.table + '"', [])
    ])
    .tap(function(resp) {
      var pragma = resp[0];
      var sql    = resp[1][0];
      command = builder.commands[builder.currentIndex];
      if (!(currentCol = _.findWhere(pragma, {name: command.from}))) {
        throw new Error('The column ' + command.from + ' is not in the current table');
      }
      return nodefn.call(connection.all.bind(connection), 'ALTER TABLE ' + sql.name + ' RENAME TO __migrate__' + sql.name);
    }).spread(function(pragma, sql) {
      sql = sql[0];
      var currentColumn = '"' + command.from + '" ' + currentCol.type;
      var newColumn     = '"' + command.to   + '" ' + currentCol.type;
      if (sql.sql.indexOf(currentColumn) === -1) {
        return trx.reject('Unable to find the column to change');
      }
      return when.all([
        nodefn.call(connection.all.bind(connection), sql.sql.replace(currentColumn, newColumn)),
        nodefn.call(connection.all.bind(connection), 'SELECT * FROM "__migrate__' + sql.name + '"'),
      ]);
    }).spread(function(createTable, selected) {
      var qb = new Builder(builder.knex).transacting(trx);
          qb.table = builder.table;
      return when.all([
        qb.insert(_.map(selected, function(row) {
          row[command.to] = row[command.from];
          return _.omit(row, command.from);
        })),
        nodefn.call(connection.all.bind(connection), 'DROP TABLE "__migrate__' + builder.table + '"')
      ]);
    }).then(trx.commit, trx.rollback);
  }

});

exports.grammar = _.defaults({

  handleResponse: function(builder, resp) {
    var ctx = resp[1]; resp = resp[0];
    if (builder.type === 'select') {
      resp = Helpers.skim(resp);
    } else if (builder.type === 'insert') {
      resp = [ctx.lastID];
    } else if (builder.type === 'delete' || builder.type === 'update') {
      resp = ctx.changes;
    }
    return resp;
  }

}, SQLite3Base.grammar);

exports.schemaGrammar = _.defaults({

  handleResponse: function(builder, resp) {
    // This is an array, so we'll assume that the relevant info is on the first statement...
    resp = resp[0];
    var ctx = resp[1]; resp = resp[0];
    if (builder.type === 'tableExists') {
      return resp.length > 0;
    } else if (builder.type === 'columnExists') {
      return _.findWhere(resp, {name: builder.bindings[1]}) != null;
    }
    return resp;
  }

}, SQLite3Base.schemaGrammar);