Jump To …

tds.js

modul TDS

Author: H.Ristau

Pure javascript modul to connect MSSQL Databases over the TDS protocol. TDS version 7.0 will be used, so connections to SQL Server 2000, 2005 and 2008 are possible.

requires:

functions:

 
var EventEmitter = require('events').EventEmitter;
var util = require('util');
var defaults =  require(__dirname + '/defaults');
var Connection = require(__dirname + '/connection');

generic-pool object 


var genericPool = require('generic-pool');

cache of existing client pools 


var pools = {};


var TDS = function(connectionConstructor) {
  EventEmitter.call(this);
  this.Connection = connectionConstructor;
  this.defaults = defaults;
};

util.inherits(TDS, EventEmitter);

top

function TDS.connect

Parameter:

  • config (s. defaults.js)
  • callback

return

  • Connection

returns a database connection. when a connectionpool is build before, a connention from the pool will be returned if one availible otherwise the pool will be build

 

TDS.prototype.connect = function(config, callback) {
  var self = this;

  var c = config;
  var cb = callback;

allow for no config to be passed 


  if(typeof c === 'function') {
    cb = c;
    c = defaults;
  }

get unique pool name even if object was used as config

 

  var poolName = typeof(c) === 'string' ? c : c.ConnectionString.Login +
                                              c.ConnectionString.Server +
                                              c.ConnectionString.Port +
                                              c.ConnectionString.Database;
  var pool = pools[poolName];

  if(pool) {
    return pool.acquire(cb);
  }

define the connectionpool 


  var pool = pools[poolName] = genericPool.Pool({

    name: poolName,

creating a connection the callback requires the parameter error and connection 


    create: function(callback) {

the connection object 


      var connection = new self.Connection(c);

      connection.connect();

function connectError handels errors

 

      var connectError = function() {
        console.log('connectError: #####################################');
        connection.removeListener('connect', connectSuccess);
        pool.destroy(connection);

callback with error 


        callback(connection.error, null);
      };

register function for error event 


      connection.on('error', connectError);

      var connectSuccess = function() {
        //console.log('connectSuccess');

handle connected connection background errors by emitting event via emit the error event and removing errored connection from the pool 


        connection.on('error', function(e) {
          console.log('error!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!');
          self.emit('error', e, connection);
          pool.destroy(connection);
        });

callback with connection 


        callback(connection.error, connection);
      };

register function connectSuccess once for login event 


      connection.once('login', connectSuccess);

register function connectErroe for error event 


      connection.on('error', connectError);

register function() for close event 


      connection.on('close', function() {
        pool.release(connection);
      });
    },

    destroy: function(connection) {
        connection.close();
    },

setting pool parameter from defaults object 


    max: defaults.poolSize,
    idleTimeoutMillis: defaults.poolIdleTimeout,
    log: false
  });


  return pool.acquire(cb);
}

top

function TDS.end

closes the database connection and destroys the connection pool

 


TDS.prototype.end = function() {
  Object.keys(pools).forEach(function(name) {
    var pool = pools[name];
    pool.drain(function() {
      pool.destroyAllNow();
    });
  })
}

module.exports = new TDS(Connection);