Add 'postgres' dialect to support PostgreSQL.

- The basic functionality seems to be working
- The DAO and DAO factory tests all pass.

.gitignore

 test*.js
+*.swp
 .idea
 .DS_STORE
 node_modules

lib/dialects/postgres/connector-manager.js

+var Query   = require("./query")
+  , Utils   = require("../../utils")
+  , without = function(arr, elem) { return arr.filter(function(e) { return e != elem }) }
+
+module.exports = (function() {
+  var ConnectorManager = function(sequelize, config) {
+    this.sequelize = sequelize
+    this.client = null
+    this.config = config || {}
+    this.disconnectTimeoutId = null
+    this.pendingQueries = 0
+    this.maxConcurrentQueries = (this.config.maxConcurrentQueries || 50)
+  }
+  Utils._.extend(ConnectorManager.prototype, require("../connector-manager").prototype)
+
+  var isConnecting = false
+  var isConnected  = false
+
+  ConnectorManager.prototype.query = function(sql, callee, options) {
+    var self = this
+    if (this.client == null) this.connect()
+    var query = new Query(this.client, callee, options || {})
+    self.pendingQueries += 1
+    return query.run(sql)
+      .success(function() { self.endQuery.call(self) })
+      .error(function() { self.endQuery.call(self) })
+  }
+
+  ConnectorManager.prototype.endQuery = function() {
+    var self = this
+    self.pendingQueries -= 1
+    if (self.pendingQueries == 0) {
+      setTimeout(function() {
+        self.pendingQueries == 0 && self.disconnect.call(self)
+      }, 100)
+    }
+  }
+
+  ConnectorManager.prototype.connect = function() {
+    var self = this
+
+    // in case database is slow to connect, prevent orphaning the client
+    if (this.isConnecting) return
+    this.isConnecting = true
+    this.isConnected  = false
+
+    var conStr = 'tcp://<%= user %>:<%= password %>@<%= host %>:<%= port %>/<%= database %>'
+    conStr = Utils._.template(conStr)({
+      user: this.config.username,
+      password: this.config.password,
+      database: this.config.database,
+      host: this.config.host,
+      port: this.config.port
+    })
+
+    var pg = require("pg")
+    this.client = new pg.Client(conStr)
+
+    this.client.connect(function(err, client) {
+      self.isConnecting = false
+      if (!err && client) {
+        self.isConnected = true
+        this.client = client
+      } else {
+        this.client = null
+      }
+    })
+  }
+
+  ConnectorManager.prototype.disconnect = function() {
+    var self = this
+    if (this.client) this.client.end()
+    this.client = null
+    this.isConnecting = false
+    this.isConnected  = false
+  }
+
+  return ConnectorManager
+})()

lib/dialects/postgres/query.js

+var Utils = require("../../utils")
+
+module.exports = (function() {
+  var Query = function(client, callee, options) {
+    var self = this
+
+    this.client = client
+    this.callee = callee
+    this.options = Utils._.extend({
+      logging: true,
+      plain: false,
+      raw: false
+    }, options || {})
+  }
+  Utils._.extend(Query.prototype, require("../query").prototype)
+
+  Query.prototype.run = function(sql) {
+    var self = this
+
+    this.sql = sql
+
+    var results = [];
+    var receivedError = false;
+
+    var query = this.client.query(sql)
+    query.on('row', function(row) {
+      if (self.callee && self.sql.indexOf('INSERT INTO') == 0) {
+        Utils._.forEach(row, function(value, key) {
+          self.callee[key] = value
+        })
+        results.push(self.callee)
+      }
+
+      if (self.sql.indexOf('SELECT table_name FROM information_schema.tables') == 0) {
+        results.push(Utils._.values(row))
+      } else if (self.sql.indexOf('SELECT') == 0) {
+        // transform results into real model instances
+        // return the first real model instance if options.plain is set (e.g. Model.find)
+        if (self.options.raw) {
+          results.push(row);
+        } else {
+          results.push(self.callee.build(row, { isNewRecord: false }))
+        }
+      } else if((self.sql.indexOf('SHOW') == 0) || (self.sql.indexOf('DESCRIBE') == 0)) {
+        results.push(row)
+      }
+    });
+
+    query.on('end', function() {
+      self.emit('sql', self.sql)
+      if (receivedError) return;
+
+      if (self.sql.indexOf('SELECT') == 0) {
+        if (self.options.plain) {
+          self.emit('success', (results.length == 0) ? null : results[0])
+        } else {
+          self.emit('success', results)
+        }
+      } else if((self.sql.indexOf('SHOW') == 0) || (self.sql.indexOf('DESCRIBE') == 0)) {
+        self.emit('success', results)
+      } else if (self.sql.indexOf('INSERT INTO') == 0) {
+        self.emit('success', results[0])
+      } else if (self.sql.indexOf('UPDATE') == 0) {
+        self.emit('success', self.callee)
+      } else {
+        self.emit('success', results)
+      }
+    });
+
+    query.on('error', function(err) {
+      receivedError = true
+      self.emit('failure', err, self.callee)
+    });
+
+    return this
+  }
+
+  return Query
+})()

package.json

@@ -20,6 +20,7 @@
   "devDependencies": {
     "jasmine-node": "1.0.22",
     "sqlite3": ">=2.0.0",
+    "pg": "0.6.x",
     "buster": "0.4.x"
   },
   "keywords": ["mysql", "orm", "nodejs", "object relational mapper"],

spec-jasmine/associations/belongs-to.spec.js

 var config    = require("../config/config")
   , Sequelize = require("../../index")
-  , sequelize = new Sequelize(config.database, config.username, config.password, { logging: false })
+  , sequelize = new Sequelize(config.mysql.database, config.mysql.username, config.mysql.password, { logging: false })
   , Helpers   = new (require("../config/helpers"))(sequelize)
 
 describe('BelongsTo', function() {

spec-jasmine/associations/has-many.spec.js

 var config    = require("../config/config")
   , Sequelize = require("../../index")
-  , sequelize = new Sequelize(config.database, config.username, config.password, { logging: false })
+  , sequelize = new Sequelize(config.mysql.database, config.mysql.username, config.mysql.password, { logging: false })
   , Helpers   = new (require("../config/helpers"))(sequelize)
 
 describe('HasMany', function() {
@@ -10,7 +10,7 @@ describe('HasMany', function() {
     , Helpers   = null
 
   var setup = function() {
-    sequelize = new Sequelize(config.database, config.username, config.password, { logging: false })
+    sequelize = new Sequelize(config.mysql.database, config.mysql.username, config.mysql.password, { logging: false })
     Helpers   = new (require("../config/helpers"))(sequelize)
 
     Helpers.dropAllTables()

spec-jasmine/associations/has-one.spec.js

 var config    = require("../config/config")
   , Sequelize = require("../../index")
-  , sequelize = new Sequelize(config.database, config.username, config.password, { logging: false })
+  , sequelize = new Sequelize(config.mysql.database, config.mysql.username, config.mysql.password, { logging: false })
   , Helpers   = new (require("../config/helpers"))(sequelize)
 
 describe('HasOne', function() {

spec-jasmine/config/config.js

 module.exports = {
+  rand: function() {
+    return parseInt(Math.random() * 999)
+  },
+
+  mysql: {
     username: "root",
     password: null,
     database: 'sequelize_test',
     host: '127.0.0.1',
-  rand: function() {
-    return parseInt(Math.random() * 999)
+    port: 3306
+  },
+
+  sqlite: {
+  },
+
+  postgres: {
+    database: 'sequelize_test',
+    port: 5432
   }
 }
 

spec-jasmine/dao-factory.spec.js

 var config    = require("./config/config")
   , Sequelize = require("../index")
-  , dialects  = ['sqlite', 'mysql']
+  , dialects  = ['sqlite', 'mysql', 'postgres']
 
 describe('DAOFactory', function() {
   dialects.forEach(function(dialect) {
     describe('with dialect "' + dialect + '"', function() {
       var User      = null
-        , sequelize = new Sequelize(config.database, config.username, config.password, {
+        , sequelize = new Sequelize(
+            config[dialect].database,
+            config[dialect].username,
+            config[dialect].password,
+            {
               logging: false,
-          dialect: dialect
-        })
+              dialect: dialect,
+              port: config[dialect].port
+            }
+          )
         , Helpers   = new (require("./config/helpers"))(sequelize)
 
       var setup = function(options) {
@@ -109,7 +115,8 @@ describe('DAOFactory', function() {
 
                 checkMatchForDialects(err.message, {
                   sqlite: /.*SQLITE_CONSTRAINT.*/,
-                  mysql: /.*Duplicate\ entry.*/
+                  mysql: /.*Duplicate\ entry.*/,
+                  postgres: /.*duplicate\ key\ value.*/
                 })
 
                 done()
@@ -130,7 +137,8 @@ describe('DAOFactory', function() {
 
               checkMatchForDialects(err.message, {
                 sqlite: /.*SQLITE_CONSTRAINT.*/,
-                mysql: "Column 'smth' cannot be null"
+                mysql: "Column 'smth' cannot be null",
+                postgres: /.*column "smth" violates not-null.*/
               })
 
               User.create({username: 'foo', smth: 'foo'}).success(function() {
@@ -139,7 +147,8 @@ describe('DAOFactory', function() {
 
                   checkMatchForDialects(err.message, {
                     sqlite: /.*SQLITE_CONSTRAINT.*/,
-                    mysql: "Duplicate entry 'foo' for key 'username'"
+                    mysql: "Duplicate entry 'foo' for key 'username'",
+                    postgres: /.*duplicate key value violates unique constraint.*/
                   })
 
                   done()

spec-jasmine/dao.spec.js

 var config    = require("./config/config")
   , Sequelize = require("../index")
-  , dialects  = ['sqlite', 'mysql']
+  , dialects  = ['sqlite', 'mysql', 'postgres']
 
 describe('DAO', function() {
   dialects.forEach(function(dialect) {
     describe('with dialect "' + dialect + '"', function() {
       var User      = null
-        , sequelize = new Sequelize(config.database, config.username, config.password, {
+        , sequelize = new Sequelize(
+            config[dialect].database,
+            config[dialect].username,
+            config[dialect].password,
+            {
               logging: false,
-          dialect: dialect
-        })
+              dialect: dialect,
+              port: config[dialect].port
+            }
+          )
         , Helpers   = new (require("./config/helpers"))(sequelize)
 
       var setup = function() {
@@ -471,7 +477,7 @@ describe('DAO', function() {
             }).success(function(user) {
               var emitter = user.updateAttributes({name: 'foobar'})
               emitter.success(function() {
-                expect(emitter.query.sql).toMatch(/WHERE `identifier`..identifier./)
+                expect(emitter.query.sql).toMatch(/WHERE `?identifier`?..identifier./)
                 done()
               })
             })

spec-jasmine/migration.spec.js

 var config    = require("./config/config")
   , Sequelize = require("../index")
-  , sequelize = new Sequelize(config.database, config.username, config.password, { logging: false })
+  , sequelize = new Sequelize(config.mysql.database, config.mysql.username, config.mysql.password, { logging: false })
   , Helpers   = new (require("./config/helpers"))(sequelize)
   , Migrator  = require("../lib/migrator")
   , Migration = require("../lib/migration")

spec-jasmine/migrator.spec.js

 var config    = require("./config/config")
   , Sequelize = require("../index")
-  , sequelize = new Sequelize(config.database, config.username, config.password, { logging: false })
+  , sequelize = new Sequelize(config.mysql.database, config.mysql.username, config.mysql.password, { logging: false })
   , Helpers   = new (require("./config/helpers"))(sequelize)
   , Migrator  = require("../lib/migrator")
   , _         = Sequelize.Utils._

spec-jasmine/mysql/associations.has-many.spec.js

 var config    = require("../config/config")
   , Sequelize = require("../../index")
-  , sequelize = new Sequelize(config.database, config.username, config.password, { logging: false })
+  , sequelize = new Sequelize(config.mysql.database, config.mysql.username, config.mysql.password, { logging: false })
   , Helpers   = new (require("../config/helpers"))(sequelize)
 
 describe('HasMany', function() {

spec-jasmine/mysql/associations.spec.js

 var config    = require("../config/config")
   , Sequelize = require("../../index")
-  , sequelize = new Sequelize(config.database, config.username, config.password, { logging: false })
+  , sequelize = new Sequelize(config.mysql.database, config.mysql.username, config.mysql.password, { logging: false })
   , Helpers   = new (require("../config/helpers"))(sequelize)
 
 describe('Associations', function() {

spec-jasmine/mysql/connector-manager.spec.js

 var config    = require("../config/config")
   , Sequelize = require("../../index")
-  , sequelize = new Sequelize(config.database, config.username, config.password, { logging: false })
+  , sequelize = new Sequelize(config.mysql.database, config.mysql.username, config.mysql.password, { logging: false })
   , Helpers   = new (require("../config/helpers"))(sequelize)
 
 describe('ConnectorManager', function() {

spec-jasmine/mysql/dao-factory.spec.js

 var config    = require("../config/config")
   , Sequelize = require("../../index")
-  , sequelize = new Sequelize(config.database, config.username, config.password, { logging: false })
+  , sequelize = new Sequelize(config.mysql.database, config.mysql.username, config.mysql.password, { logging: false })
   , Helpers   = new (require("../config/helpers"))(sequelize)
 
 describe('DAOFactory', function() {

spec-jasmine/mysql/query-generator.spec.js

 var config         = require("../config/config")
   , Sequelize      = require("../../index")
-  , sequelize      = new Sequelize(config.database, config.username, config.password, { logging: false })
+  , sequelize      = new Sequelize(config.mysql.database, config.mysql.username, config.mysql.password, { logging: false })
   , Helpers        = new (require("../config/helpers"))(sequelize)
   , QueryGenerator = require("../../lib/dialects/mysql/query-generator")
   , util          = require("util")

spec-jasmine/query-interface.spec.js

 var config         = require("./config/config")
   , Sequelize      = require("../index")
-  , sequelize      = new Sequelize(config.database, config.username, config.password, { logging: false })
+  , sequelize      = new Sequelize(config.mysql.database, config.mysql.username, config.mysql.password, { logging: false })
   , Helpers        = new (require("./config/helpers"))(sequelize)
   , QueryInterface = require("../lib/query-interface")
 

spec-jasmine/sequelize.spec.js

@@ -9,7 +9,7 @@ describe('Sequelize', function() {
 
   var setup = function(options) {
     options   = options || {logging: false}
-    sequelize = new Sequelize(config.database, config.username, config.password, options)
+    sequelize = new Sequelize(config.mysql.database, config.mysql.username, config.mysql.password, options)
     Helpers   = new (require("./config/helpers"))(sequelize)
 
     return options