Merge branch 'master' into milestones/2.0.0

Conflicts: lib/emitters/custom-event-emitter.js spec-jasmine/dao.spec.js spec/associations/has-one.spec.js spec/dao.spec.js spec/promise.spec.js test/dao.validations.test.js

Merge branch 'master' into milestones/2.0.0
Conflicts: lib/emitters/custom-event-emitter.js spec-jasmine/dao.spec.js spec/associations/has-one.spec.js spec/dao.spec.js spec/promise.spec.js test/dao.validations.test.js
Daniel Durante
Commit 83f94b36 authored Jul 30, 2013 by Daniel Durante
Showing with 1005 additions and 3128 deletions
.jshintrc
.travis.yml
Makefile
README.md
changelog.md
examples/enforce-referential-integrity/app.js
examples/enforce-referential-integrity/models/Series.js
examples/enforce-referential-integrity/models/Trainer.js
examples/enforce-referential-integrity/models/Video.js
examples/enforce-referential-integrity/results.md
lib/associations/has-many-double-linked.js
lib/associations/has-many-single-linked.js
lib/associations/has-one.js
lib/dao-factory-manager.js
lib/dao-factory.js
lib/dao.js
lib/dialects/mysql/connector-manager.js
lib/dialects/mysql/query-generator.js
lib/dialects/postgres/connector-manager.js
lib/dialects/postgres/query-generator.js
--- a/.jshintrc
+++ b/.jshintrc
 {
    "globals": {
-        "jasmine": false,
        "spyOn": false,
        "it": false,
        "console": false,

--- a/.travis.yml
+++ b/.travis.yml
@@ -3,8 +3,7 @@ before_script:
  - "psql -c 'create database sequelize_test;' -U postgres"
 script:
-  - "npm run test-buster-travis"
+  - "make test"
-  - "npm run test-jasmine"
 notifications:
  email:

--- a/Makefile
+++ b/Makefile
+REPORTER ?= dot
+TESTS = $(shell find ./test/* -name "*.test.js")
+DIALECT ?= mysql
+# test commands
+teaser:
+	@echo "" && \
+	node -pe "Array(20 + '$(DIALECT)'.length + 3).join('#')" && \
+	echo '# Running tests for $(DIALECT) #' && \
+	node -pe "Array(20 + '$(DIALECT)'.length + 3).join('#')" && \
+	echo ''
+test:
+	@make teaser && \
+	./node_modules/mocha/bin/mocha \
+	--colors \
+	--reporter $(REPORTER) \
+	$(TESTS)
+sqlite:
+	@DIALECT=sqlite make test
+mysql:
+	@DIALECT=mysql make test
+postgres:
+	@DIALECT=postgres make test
+postgres-native:
+	@DIALECT=postgres-native make test
+# test aliases
+pgsql: postgres
+postgresn: postgres-native
+# test all the dialects \o/
+all: sqlite mysql postgres postgres-native
+.PHONY: sqlite mysql postgres pgsql postgres-native postgresn all test
\ No newline at end of file
--- a/README.md
+++ b/README.md
-# Sequelize #
+# Sequelize [![Build Status](https://secure.travis-ci.org/sequelize/sequelize.png)](http://travis-ci.org/sequelize/sequelize) [![Dependency Status](https://david-dm.org/sequelize/sequelize.png)](https://david-dm.org/sequelize/sequelize) [![Dependency Status](https://david-dm.org/sequelize/sequelize.png)](https://david-dm.org/sequelize/sequelize) [![Flattr this](http://api.flattr.com/button/flattr-badge-large.png)](http://flattr.com/thing/1259407/Sequelize) #
-The Sequelize library provides easy access to MySQL, SQLite or PostgreSQL databases by mapping database entries to objects and vice versa. To put it in a nutshell... it's an ORM (Object-Relational-Mapper). The library is written entirely in JavaScript and can be used in the Node.JS environment.
+MySQL, PostgresSQL, and SQLite Object Relational Mapper (ORM) for [node](http://nodejs.org).
-<a href="http://flattr.com/thing/1259407/Sequelize" target="_blank">
-<img src="http://api.flattr.com/button/flattr-badge-large.png" alt="Flattr this" title="Flattr this" border="0" /></a>
 ## Important Notes ##
@@ -35,6 +32,7 @@ changelog of the branch: https://github.com/sequelize/sequelize/blob/milestones/
 - Asynchronous library
 - Associations
 - Importing definitions from single files
+- Promises
 ## Documentation and Updates ##
@@ -64,7 +62,7 @@ A very basic roadmap. Chances aren't too bad, that not mentioned things are impl
 - MariaDB support
 - ~~Support for update and delete calls for whole tables without previous loading of instances~~ Implemented in [#569](https://github.com/sequelize/sequelize/pull/569) thanks to @optiltude
 - Eager loading of nested associations [#388](https://github.com/sdepold/sequelize/issues/388#issuecomment-12019099)
- Model#delete
+- ~~Model#delete~~ (renamed to [Model.destroy()](http://sequelizejs.com/documentation#instances-destroy))
 - ~~Validate a model before it gets saved.~~ Implemented in [#601](https://github.com/sequelize/sequelize/pull/601), thanks to @durango
 - Move validation of enum attribute value to validate method
 - BLOB [#99](https://github.com/sequelize/sequelize/issues/99)
@@ -142,9 +140,7 @@ $ npm install
 ### 4. Run the tests ###
 Right now, the test base is split into the `spec` folder (which contains the
-lovely [BusterJS](http://busterjs.org) tests) and the `spec-jasmine` folder
+lovely [BusterJS](http://busterjs.org) tests).
-(which contains the ugly and awkward node-jasmine based tests). A main goal
-is to get rid of the jasmine tests!
 As you might haven't installed all of the supported SQL dialects, here is how
 to run the test suites for your development environment:
@@ -153,9 +149,6 @@ to run the test suites for your development environment:
 $ # run all tests at once:
 $ npm test
-$ # run only the jasmine tests (for all dialects):
-$ npm run test-jasmine
 $ # run all of the buster specs (for all dialects):
 $ npm run test-buster
@@ -167,6 +160,9 @@ $ npm run test-buster-sqlite
 $ # run the buster specs for postgresql:
 $ npm run test-buster-postgres
+$ # alternatively you can pass database credentials with $variables when testing with buster.js
+$ DIALECT=dialect SEQ_DB=database SEQ_USER=user SEQ_PW=password buster-test
 ```
 ### 5. That's all ###
@@ -235,6 +231,17 @@ for (var key in obj) {
 ```js
 {
+  "globals": {
+    "spyOn": false,
+    "it": false,
+    "console": false,
+    "describe": false,
+    "expect": false,
+    "beforeEach": false,
+    "waits": false,
+    "waitsFor": false,
+    "runs": false
+  },
  "camelcase": true,
  "curly": true,
  "forin": true,
@@ -246,10 +253,3 @@ for (var key in obj) {
  "es5": true
 }
 ```
-# Build status
-The automated tests we talk about just so much are running on
-[Travis public CI](http://travis-ci.org), here is its status:
-[![Build Status](https://secure.travis-ci.org/sequelize/sequelize.png)](http://travis-ci.org/sequelize/sequelize)
--- a/changelog.md
+++ b/changelog.md
@@ -20,6 +20,10 @@
 - [BUG] PostgreSQL should now be able to insert empty arrays with typecasting. [#718](https://github.com/sequelize/sequelize/pull/718). thanks to durango
 - [BUG] Fields should be escaped by quoteIdentifier for max/min functions which allows SQL reserved keywords to be used. [#719](https://github.com/sequelize/sequelize/pull/719). thanks to durango
 - [BUG] Fixed bug when trying to save objects with eagerly loaded attributes [#716](https://github.com/sequelize/sequelize/pull/716). thanks to iamjochen
+- [BUG] Strings for .find() should be fixed. Also added support for string primary keys to be found easily. [#737](https://github.com/sequelize/sequelize/pull/737). thanks to durango
+- [BUG] bulkCreate would have problems with a disparate field list [#738](https://github.com/sequelize/sequelize/pull/738). thanks to durango
+- [BUG] Fixed problems with quoteIdentifiers and {raw: false} option on raw queries [#751](https://github.com/sequelize/sequelize/pull/751). thanks to janmeier
+- [BUG] Fixed SQL escaping with sqlite and unified escaping [#700](https://github.com/sequelize/sequelize/pull/700). thanks to PiPeep
 - [FEATURE] Validate a model before it gets saved. [#601](https://github.com/sequelize/sequelize/pull/601). thanks to durango
 - [FEATURE] Schematics. [#564](https://github.com/sequelize/sequelize/pull/564). thanks to durango
 - [FEATURE] Foreign key constraints. [#595](https://github.com/sequelize/sequelize/pull/595). thanks to optilude
@@ -33,11 +37,16 @@
 - [FEATURE] `findOrCreate` now returns an additional flag (`created`), that is true if a model was created, and false if it was found [#648](https://github.com/sequelize/sequelize/pull/648). janmeier
 - [FEATURE] Field and table comments for MySQL and PG. [#523](https://github.com/sequelize/sequelize/pull/523). MySQL by iamjochen. PG by janmeier
 - [FEATURE] BigInts can now be used for autoincrement/serial columns. [#673](https://github.com/sequelize/sequelize/pull/673). thanks to sevastos
- [REFACTORING] hasMany now uses a single SQL statement when creating and destroying associations, instead of removing each association seperately [690](https://github.com/sequelize/sequelize/pull/690). Inspired by [#104](https://github.com/sequelize/sequelize/issues/104). janmeier
 - [FEATURE] Use moment for better postgres timestamp strings. [#710](https://github.com/sequelize/sequelize/pull/710). Thanks to seth-admittedly
 - [FEATURE] Keep milliseconds in timestamps for postgres. [#712](https://github.com/sequelize/sequelize/pull/712). Thanks to seth-admittedly
 - [FEATURE] You can now set lingo's language through Sequelize. [#713](https://github.com/sequelize/sequelize/pull/713). Thanks to durango
 - [FEATURE] Added a `findAndCountAll`, useful for pagination. [#533](https://github.com/sequelize/sequelize/pull/533). Thanks to iamjochen
+- [FEATURE] Made explicit migrations possible. [#728](https://github.com/sequelize/sequelize/pull/728). Thanks to freezy
+- [FEATURE] Added support for where clauses containing !=, < etc. and support for date ranges  [#727](https://github.com/sequelize/sequelize/pull/727). Thanks to durango
+- [FEATURE] Added support for model instances being referenced [#761](https://github.com/sequelize/sequelize/pull/761) thanks to sdepold
+- [FEATURE] Added support for specifying the path to load a module for a dialect. [#766](https://github.com/sequelize/sequelize/pull/766) thanks to sonnym.
+- [REFACTORING] hasMany now uses a single SQL statement when creating and destroying associations, instead of removing each association seperately [690](https://github.com/sequelize/sequelize/pull/690). Inspired by [#104](https://github.com/sequelize/sequelize/issues/104). janmeier
+- [REFACTORING] Consistent handling of offset across dialects. Offset is now always applied, and limit is set to max table size of not limit is given [#725](https://github.com/sequelize/sequelize/pull/725). janmeier
 # v1.6.0 #
 - [DEPENDENCIES] upgrade mysql to alpha7. You *MUST* use this version or newer for DATETIMEs to work

--- a/examples/enforce-referential-integrity/app.js
+++ b/examples/enforce-referential-integrity/app.js
+/*jslint node:true */
+"use strict";
+var Sequelize = require('sequelize');
+// initialize database connection
+var sequelize = new Sequelize('testsequelize', 'testsequelize', 'testsequelize', {
+    dialect: 'postgres',
+    port: 5432,
+    define: {
+        freezeTableName: true
+    }
+});
+// load models
+var models = [
+    'Trainer',
+    'Series',
+    'Video'
+];
+models.forEach(function(model) {
+    module.exports[model] = sequelize.import(__dirname + '/' + model);
+});
+// describe relationships
+(function(m) {
+    m.Series.hasOne(m.Video);
+    m.Trainer.hasMany(m.Series);
+})(module.exports);
+// export connection
+module.exports.sequelize = sequelize;
\ No newline at end of file
--- a/examples/enforce-referential-integrity/models/Series.js
+++ b/examples/enforce-referential-integrity/models/Series.js
+/*jslint node:true */
+"use strict";
+module.exports = function(sequelize, DataTypes) {
+    return sequelize.define('Series', {
+        title: {
+            type: DataTypes.STRING
+        },
+        sub_title: {
+            type: DataTypes.STRING
+        },
+        description: {
+            type: DataTypes.TEXT
+        },
+        // Set FK relationship (hasMany) with `Trainer`
+        trainer_id: {
+            type: DataTypes.INTEGER,
+            references: "Trainer",
+            referencesKey: 'id'
+        }
+    }, {
+        // don't need timestamp attributes for this model
+        timestamps: false,
+        underscored: true
+    });
+};
--- a/examples/enforce-referential-integrity/models/Trainer.js
+++ b/examples/enforce-referential-integrity/models/Trainer.js
+/*jslint node:true */
+"use strict";
+module.exports = function(sequelize, DataTypes) {
+    return sequelize.define('Trainer', {
+        first_name: {
+            type: DataTypes.STRING
+        },
+        last_name: {
+            type: DataTypes.STRING
+        }
+    }, {
+        // don't need timestamp attributes for this model
+        timestamps: false,
+        underscored: true
+    });
+};
--- a/examples/enforce-referential-integrity/models/Video.js
+++ b/examples/enforce-referential-integrity/models/Video.js
+/*jslint node:true */
+"use strict";
+module.exports = function(sequelize, DataTypes) {
+    return sequelize.define('Video', {
+        title: {
+            type: DataTypes.STRING
+        },
+        sequence: {
+            type: DataTypes.INTEGER
+        },
+        description: {
+            type: DataTypes.TEXT
+        },
+        // set relationship (hasOne) with `Series`
+        series_id: {
+            type: DataTypes.INTEGER,
+            references: "Series",
+            referencesKey: 'id'
+        }
+    }, {
+        // don't need timestamp attributes for this model
+        timestamps: false,
+        underscored: true
+    });
+};
--- a/examples/enforce-referential-integrity/results.md
+++ b/examples/enforce-referential-integrity/results.md
+Results after syncing the dabatase
+----------------------------------
+After syncing the database, you'll see in the console the following:
+```
+Executing: CREATE TABLE IF NOT EXISTS "Trainer" ("first_name" VARCHAR(255), "last_name" VARCHAR(255), "id"   SERIAL , PRIMARY KEY ("id"));
+Executing: CREATE TABLE IF NOT EXISTS "Series" ("title" VARCHAR(255), "sub_title" VARCHAR(255), "description" TEXT, "trainer_id" INTEGER REFERENCES "Trainer" ("id"), "id"   SERIAL , PRIMARY KEY ("id"));
+Executing: CREATE TABLE IF NOT EXISTS "Video" ("title" VARCHAR(255), "sequence" INTEGER, "description" TEXT, "series_id" INTEGER REFERENCES "Series" ("id"), "id"   SERIAL , PRIMARY KEY ("id"));
+```
+Notice in the `Video` that `series_id` field has a referential integrity to `Series`:
+```
+"series_id" INTEGER REFERENCES "Series" ("id")
+```
+This is the output when describing the table's structure of the Postgres database:
+**Trainer** table:
+```
+testsequelize=> \d+ "Trainer";
+                                                        Table "public.Trainer"
+   Column   |          Type          |                       Modifiers                        |
+------------+------------------------+--------------------------------------------------------+
+ first_name | character varying(255) |                                                        |
+ last_name  | character varying(255) |                                                        |
+ id         | integer                | not null default nextval('"Trainer_id_seq"'::regclass) |
+Indexes:
+    "Trainer_pkey" PRIMARY KEY, btree (id)
+Referenced by:
+    TABLE ""Series"" CONSTRAINT "Series_trainer_id_fkey" FOREIGN KEY (trainer_id) REFERENCES "Trainer"(id)
+Has OIDs: no
+```
+**Series** table:
+```
+testsequelize=> \d+ "Series";
+                                                          Table "public.Series"
+     Column      |          Type          |                       Modifiers                       |
+-----------------+------------------------+-------------------------------------------------------+
+ title           | character varying(255) |                                                       |
+ sub_title       | character varying(255) |                                                       |
+ description     | text                   |                                                       |
+ trainer_id      | integer                |                                                       |
+ id              | integer                | not null default nextval('"Series_id_seq"'::regclass) |
+Indexes:
+    "Series_pkey" PRIMARY KEY, btree (id)
+Foreign-key constraints:
+    "Series_trainer_id_fkey" FOREIGN KEY (trainer_id) REFERENCES "Trainer"(id)
+Referenced by:
+    TABLE ""Video"" CONSTRAINT "Video_series_id_fkey" FOREIGN KEY (series_id) REFERENCES "Series"(id)
+Has OIDs: no
+```
+**Video** table:
+```
+testsequelize=> \d+ "Video";
+                                                        Table "public.Video"
+   Column    |          Type          |                      Modifiers                       |
+-------------+------------------------+------------------------------------------------------+
+ title       | character varying(255) |                                                      |
+ sequence    | integer                |                                                      |
+ description | text                   |                                                      |
+ series_id   | integer                |                                                      |
+ id          | integer                | not null default nextval('"Video_id_seq"'::regclass) |
+Indexes:
+    "Video_pkey" PRIMARY KEY, btree (id)
+Foreign-key constraints:
+    "Video_series_id_fkey" FOREIGN KEY (series_id) REFERENCES "Series"(id)
+Has OIDs: no
+```
--- a/lib/associations/has-many-double-linked.js
+++ b/lib/associations/has-many-double-linked.js
@@ -21,12 +21,26 @@ module.exports = (function() {
      where[self.__factory.connectorDAO.tableName+"."+foreignKey] = {join: self.__factory.target.tableName+".id"}
      if (options.where) {
+        if (Array.isArray(options.where)) {
+          smart = Utils.smartWhere([where, options.where], self.__factory.target.daoFactoryManager.sequelize.options.dialect)
+          smart = Utils.compileSmartWhere.call(self.__factory.target, smart, self.__factory.target.daoFactoryManager.sequelize.options.dialect)
+          if (smart.length > 0) {
+            options.where = smart
+          }
+        } else {
          Utils._.each(options.where, function(value, index) {
            delete options.where[index];
+            smart = Utils.smartWhere(value, self.__factory.target.daoFactoryManager.sequelize.options.dialect)
+            smart = Utils.compileSmartWhere.call(self.__factory.target, smart)
+            if (smart.length > 0) {
+              value = smart
+            }
            options.where[self.__factory.target.tableName+"."+index] = value;
          });
-        Utils._.extend(options.where, where)
+          options.where = Utils._.extend(options.where, where)
+        }
      } else {
        options.where = where;
      }

--- a/lib/associations/has-many-single-linked.js
+++ b/lib/associations/has-many-single-linked.js
@@ -12,8 +12,17 @@ module.exports = (function() {
    where[this.__factory.identifier] = this.instance.id
-    options.where = options.where ? Utils._.extend(options.where, where) : where
+    if (options.where) {
-    return this.__factory.target.findAll(options)
+      smart = Utils.smartWhere([where, options.where], this.__factory.target.daoFactoryManager.sequelize.options.dialect)
+      smart = Utils.compileSmartWhere.call(this.__factory.target, smart)
+      if (smart.length > 0) {
+        options.where = smart
+      }
+    } else {
+      options.where = where
+    }
+    return this.__factory.target.all(options)
  }
  HasManySingleLinked.prototype.injectSetter = function(emitter, oldAssociations, newAssociations) {
@@ -34,7 +43,7 @@ module.exports = (function() {
    if (obsoleteAssociations.length > 0) {
      // clear the old associations
      var obsoleteIds = obsoleteAssociations.map(function(associatedObject) {
-        associatedObject[self.__factory.identifier] = null
+        associatedObject[self.__factory.identifier] = (newAssociations.length < 1 ? null : self.instance.id)
        return associatedObject.id
      })
@@ -46,12 +55,12 @@ module.exports = (function() {
    if (unassociatedObjects.length > 0) {
      // set the new associations
      var unassociatedIds = unassociatedObjects.map(function(associatedObject) {
-        associatedObject[self.__factory.identifier] = self.instance.id
+        associatedObject[self.__factory.identifier] = (newAssociations.length < 1 ? null : self.instance.id)
        return associatedObject.id
      })
      update = {}
-      update[self.__factory.identifier] = self.instance.id
+      update[self.__factory.identifier] = (newAssociations.length < 1 ? null : self.instance.id)
      chainer.add(this.__factory.target.update(update, { id: unassociatedIds }))
    }

--- a/lib/associations/has-one.js
+++ b/lib/associations/has-one.js
@@ -56,6 +56,12 @@ module.exports = (function() {
        params = {where: where}
      }
+      smart = Utils.smartWhere([where, params.where || []], self.target.daoFactoryManager.sequelize.options.dialect)
+      smart = Utils.compileSmartWhere.call(self.target, smart)
+      if (smart.length > 0) {
+        params.where = smart
+      }
      return self.target.find(params)
    }
@@ -64,17 +70,25 @@ module.exports = (function() {
  HasOne.prototype.injectSetter = function(obj) {
    var self    = this
-      , options = self.options || {}
    obj[this.accessors.set] = function(associatedObject) {
-      var instance = this;
+      var instance = this
      return new Utils.CustomEventEmitter(function(emitter) {
        instance[self.accessors.get]().success(function(oldObj) {
          if (oldObj) {
            oldObj[self.identifier] = null
-            oldObj.save()
+            oldObj.save().success(function() {
+              if (associatedObject) {
+                associatedObject[self.identifier] = instance.id
+                associatedObject
+                  .save()
+                  .success(function() { emitter.emit('success', associatedObject) })
+                  .error(function(err) { emitter.emit('error', err) })
+              } else {
+                emitter.emit('success', null)
              }
+            })
+          } else {
            if (associatedObject) {
              associatedObject[self.identifier] = instance.id
              associatedObject
@@ -84,7 +98,7 @@ module.exports = (function() {
            } else {
              emitter.emit('success', null)
            }
+          }
        })
      }).run()
    }

--- a/lib/dao-factory-manager.js
+++ b/lib/dao-factory-manager.js
 var Toposort   = require('toposort-class')
+  , DaoFactory = require('./dao-factory')
 module.exports = (function() {
  var DAOFactoryManager = function(sequelize) {
@@ -43,12 +44,13 @@ module.exports = (function() {
      , sorter = new Toposort()
    this.daos.forEach(function(dao) {
-      daos[dao.tableName] = dao
      var deps = []
-      for(var attrName in dao.rawAttributes) {
+      daos[dao.tableName] = dao
-        if(dao.rawAttributes.hasOwnProperty(attrName)) {
-          if(dao.rawAttributes[attrName].references) {
+      for (var attrName in dao.rawAttributes) {
+        if (dao.rawAttributes.hasOwnProperty(attrName)) {
+          if (dao.rawAttributes[attrName].references) {
            deps.push(dao.rawAttributes[attrName].references)
          }
        }

--- a/lib/dao-factory.js
+++ b/lib/dao-factory.js
@@ -5,8 +5,6 @@ var Utils     = require("./utils")
 module.exports = (function() {
  var DAOFactory = function(name, attributes, options) {
-    var self = this
    this.options = Utils._.extend({
      timestamps: true,
      instanceMethods: {},
@@ -24,18 +22,25 @@ module.exports = (function() {
    // error check options
    Utils._.each(options.validate, function(validator, validatorType) {
-      if (Utils._.contains(Utils._.keys(attributes), validatorType))
+      if (Utils._.contains(Utils._.keys(attributes), validatorType)) {
        throw new Error("A model validator function must not have the same name as a field. Model: " + name + ", field/validation name: " + validatorType)
-      if (!Utils._.isFunction(validator))
+      }
+      if (!Utils._.isFunction(validator)) {
        throw new Error("Members of the validate option must be functions. Model: " + name + ", error with validate member " + validatorType)
+      }
    })
    this.name = name
    if (!this.options.tableName) {
      this.tableName = this.options.freezeTableName ? name : Utils.pluralize(name, this.options.language)
    } else {
      this.tableName = this.options.tableName
    }
+    attributes = replaceReferencesWithTableNames(attributes)
    this.rawAttributes     = attributes
    this.daoFactoryManager = null // defined in init function
    this.associations      = {}
@@ -59,8 +64,8 @@ module.exports = (function() {
    var self = this;
    this.daoFactoryManager = daoFactoryManager
    this.primaryKeys       = {};
    Utils._.each(this.attributes, function(dataTypeString, attributeName) {
      if ((attributeName !== 'id') && (dataTypeString.indexOf('PRIMARY KEY') !== -1)) {
        self.primaryKeys[attributeName] = dataTypeString
@@ -75,9 +80,11 @@ module.exports = (function() {
    findAutoIncrementField.call(this)
    // DAO prototype
+    // WTF ... ?
    this.DAO = function() {
      DAO.apply(this, arguments);
-    };
+    }
    Util.inherits(this.DAO, DAO);
    this.DAO.prototype.rawAttributes = this.rawAttributes;
@@ -89,47 +96,48 @@ module.exports = (function() {
    }
    Utils._.each(['Get', 'Set'], function(type) {
-      var prop  = type.toLowerCase(),
+      var prop  = type.toLowerCase()
-          opt   = prop + 'terMethods',
+        , opt   = prop + 'terMethods'
-          meth  = '__define' + type + 'ter__',
+        , meth  = '__define' + type + 'ter__'
-          funcs = Utils._.isObject(self.options[opt]) ? self.options[opt] : {}
+        , funcs = Utils._.isObject(self.options[opt]) ? self.options[opt] : {}
-      ;
      Utils._.each(self.rawAttributes, function(attr, name) {
-        if (attr.hasOwnProperty(prop))
+        if (attr.hasOwnProperty(prop)) {
          funcs[name] = attr[prop]
-      });
+        }
+      })
      Utils._.each(funcs, function(fct, name) {
-        if (!Utils._.isFunction(fct))
+        if (!Utils._.isFunction(fct)) {
          throw new Error(type + 'ter for "' + name + '" is not a function.')
+        }
-        self.DAO.prototype[meth](name, fct);
+        self.DAO.prototype[meth](name, fct)
      })
    })
    this.DAO.prototype.attributes    = Object.keys(this.DAO.prototype.rawAttributes);
+    this.DAO.prototype.booleanValues = []
+    this.DAO.prototype.defaultValues = {}
+    this.DAO.prototype.validators    = {}
-    this.DAO.prototype.booleanValues = [];
-    this.DAO.prototype.defaultValues = {};
-    this.DAO.prototype.validators = {};
    Utils._.each(this.rawAttributes, function (definition, name) {
      if (((definition === DataTypes.BOOLEAN) || (definition.type === DataTypes.BOOLEAN))) {
        self.DAO.prototype.booleanValues.push(name);
      }
      if (definition.hasOwnProperty('defaultValue')) {
        self.DAO.prototype.defaultValues[name] = function() {
-          return Utils.toDefaultValue(definition.defaultValue);
+          return Utils.toDefaultValue(definition.defaultValue)
        }
      }
      if (definition.hasOwnProperty('validate')) {
        self.DAO.prototype.validators[name] = definition.validate;
      }
-    });
+    })
-    this.DAO.prototype.__factory = this;
+    this.DAO.prototype.__factory        = this
-    this.DAO.prototype.hasDefaultValues = !Utils._.isEmpty(this.DAO.prototype.defaultValues);
+    this.DAO.prototype.hasDefaultValues = !Utils._.isEmpty(this.DAO.prototype.defaultValues)
    return this
  }
@@ -278,6 +286,17 @@ module.exports = (function() {
      // whereCollection is used for non-primary key updates
      this.options.whereCollection = options.where || null
+    } else if (typeof options === "string") {
+      var where = {}
+        , keys = Object.keys(primaryKeys)
+      if (this.primaryKeyCount === 1) {
+        where[primaryKeys[keys[0]]] = options;
+        options = where;
+      } else if (this.primaryKeyCount < 1) {
+        // Revert to default behavior which is {where: [int]}
+        options = {where: parseInt(Number(options) || 0, 0)}
+      }
    }
    options.limit = 1
@@ -421,39 +440,26 @@ module.exports = (function() {
      , updatedAtAttr = self.options.underscored ? 'updated_at' : 'updatedAt'
      , createdAtAttr = self.options.underscored ? 'created_at' : 'createdAt'
+    fields = fields || []
    // we will re-create from DAOs, which may have set up default attributes
    records = []
+    var found = false
-    if (fields) {
-      // Always insert updated and created time stamps
-      if (self.options.timestamps) {
-        if (fields.indexOf(updatedAtAttr) === -1) {
-          fields.push(updatedAtAttr)
-        }
-        if (fields.indexOf(createdAtAttr) === -1) {
-          fields.push(createdAtAttr)
-        }
-      }
-      // Build records for the fields we know about
    daos.forEach(function(dao) {
-        var values = {};
+      var values = fields.length > 0 ? {} : dao.dataValues
      fields.forEach(function(field) {
        values[field] = dao.dataValues[field]
      })
      if (self.options.timestamps) {
+        values[createdAtAttr] = Utils.now()
        values[updatedAtAttr] = Utils.now()
      }
-        records.push(values);
-      })
-    } else {
+      records.push(values);
-      daos.forEach(function(dao) {
-        records.push(dao.dataValues)
    })
-    }
    // Validate enums
    records.forEach(function(values) {
@@ -509,6 +515,10 @@ module.exports = (function() {
    return this.QueryInterface.bulkUpdate(this.tableName, attrValueHash, where)
  }
+  DAOFactory.prototype.describe = function() {
+    return this.QueryInterface.describeTable(this.tableName)
+  }
  // private
  var query = function() {
@@ -616,6 +626,16 @@ module.exports = (function() {
    }
  }
+  var replaceReferencesWithTableNames = function(attributes) {
+    Object.keys(attributes).forEach(function(attrName) {
+      if (attributes[attrName].references instanceof DAOFactory) {
+        attributes[attrName].references = attributes[attrName].references.tableName
+      }
+    })
+    return attributes
+  }
  Utils._.extend(DAOFactory.prototype, require("./associations/mixin"))
  return DAOFactory

--- a/lib/dao.js
+++ b/lib/dao.js
@@ -399,6 +399,20 @@ module.exports = (function() {
    for (key in attrs) {
      this.addAttribute(key, attrs[key])
    }
+    // this.addAttributes COMPLETELY destroys the structure of our DAO due to __defineGetter__ resetting the object
+    // so now we have to rebuild for bulkInserts, bulkUpdates, etc.
+    var rebuild = {}
+    // Get the correct map....
+    Utils._.each(this.attributes, function(key) {
+      if (this.dataValues.hasOwnProperty(key)) {
+        rebuild[key] = this.dataValues[key]
+      }
+    }.bind(this))
+    // This allows for aliases, etc.
+    this.dataValues = Utils._.extend(rebuild, this.dataValues)
  }
  return DAO

--- a/lib/dialects/mysql/connector-manager.js
+++ b/lib/dialects/mysql/connector-manager.js
@@ -4,11 +4,18 @@ var mysql
  , Utils   = require("../../utils")
  , without = function(arr, elem) { return arr.filter(function(e) { return e != elem }) }
-try { mysql = require("mysql") } catch (err) {
-  console.log("You need to install mysql package manually"); }
 module.exports = (function() {
  var ConnectorManager = function(sequelize, config) {
+    try {
+      if (config.dialectModulePath) {
+        mysql = require(config.dialectModulePath)
+      } else {
+        mysql = require('mysql')
+      }
+    } catch (err) {
+      console.log('You need to install mysql package manually')
+    }
    this.sequelize = sequelize
    this.client = null
    this.config = config || {}
@@ -75,7 +82,9 @@ module.exports = (function() {
        read: Pooling.Pool({
          name: 'sequelize-read',
          create: function (done) {
-            if (reads >= self.config.replication.read.length) reads = 0;
+            if (reads >= self.config.replication.read.length) {
+              reads = 0
+            }
            var config = self.config.replication.read[reads++];
            connect.call(self, function (err, connection) {
@@ -161,11 +170,12 @@ module.exports = (function() {
    query.done(function() {
      self.pendingQueries--;
-      if (self.pool) self.pool.release(query.client);
+      if (self.pool) {
-      else {
+        self.pool.release(query.client);
+      } else {
        if (self.pendingQueries === 0) {
          setTimeout(function() {
-            self.pendingQueries === 0 && self.disconnect.call(self);
+            self.pendingQueries === 0 && self.disconnect.call(self)
          }, 100);
        }
      }
@@ -173,16 +183,16 @@ module.exports = (function() {
    if (!this.pool) {
      query.run(sql);
-    }
+    } else {
-    else {
      this.pool.acquire(function(err, client) {
-        if (err) return query.emit('error', err);
+        if (err) {
+          return query.emit('error', err)
+        }
-        query.client = client;
+        query.client = client
-        query.run(sql);
+        query.run(sql)
        return;
-      }, undefined, options.type);
+      }, undefined, options.type)
    }
    return query;
@@ -202,8 +212,10 @@ module.exports = (function() {
  };
  ConnectorManager.prototype.disconnect = function() {
-    if (this.client) disconnect.call(this, this.client);
+    if (this.client) {
-    return;
+      disconnect.call(this, this.client)
+    }
+    return
  };
@@ -258,12 +270,12 @@ module.exports = (function() {
        switch(err.code) {
        case 'ECONNREFUSED':
        case 'ER_ACCESS_DENIED_ERROR':
-          emitter.emit('error', new Error("Failed to authenticate for MySQL. Please double check your settings."))
+          emitter.emit('error', 'Failed to authenticate for MySQL. Please double check your settings.')
          break
        case 'ENOTFOUND':
        case 'EHOSTUNREACH':
        case 'EINVAL':
-          emitter.emit('error', new Error("Failed to find MySQL server. Please double check your settings."))
+          emitter.emit('error', 'Failed to find MySQL server. Please double check your settings.')
          break
        }
      }
@@ -288,7 +300,7 @@ module.exports = (function() {
  }
  var validateConnection = function(client) {
-    return client && client.state != 'disconnected'
+    return client && client.state !== 'disconnected'
  }
  var enqueue = function(queueItem, options) {
@@ -335,8 +347,6 @@ module.exports = (function() {
  }
  var afterQuery = function(queueItem) {
-    var self = this
    dequeue.call(this, queueItem)
    transferQueuedItems.call(this, this.maxConcurrentQueries - this.activeQueue.length)
    disconnectIfNoConnections.call(this)

--- a/lib/dialects/mysql/query-generator.js
+++ b/lib/dialects/mysql/query-generator.js
 var Utils     = require("../../utils")
  , DataTypes = require("../../data-types")
+  , SqlString = require("../../sql-string")
  , util      = require("util")
 module.exports = (function() {
@@ -28,9 +29,8 @@ module.exports = (function() {
      return Utils._.template(query)({})
    },
-    dropSchema: function() {
+    dropSchema: function(tableName, options) {
-      var query = "SHOW TABLES"
+      return QueryGenerator.dropTableQuery(tableName, options)
-      return Utils._.template(query)({})
    },
    showSchemasQuery: function() {
@@ -217,8 +217,14 @@ module.exports = (function() {
        query += " ORDER BY " + options.order
      }
+      if (options.offset && !options.limit) {
-      if (options.limit && !(options.include && (options.limit === 1))) {
+        /*
+         * If no limit is defined, our best bet is to use the max number of rows in a table. From the MySQL docs:
+         * There is a limit of 2^32 (~4.295E+09) rows in a MyISAM table. If you build MySQL with the --with-big-tables option,
+         * the row limitation is increased to (2^32)^2 (1.844E+19) rows.
+         */
+        query += " LIMIT " + options.offset + ", " + 18440000000000000000;
+      } else if (options.limit && !(options.include && (options.limit === 1))) {
        if (options.offset) {
          query += " LIMIT " + options.offset + ", " + options.limit
        } else {
@@ -529,7 +535,6 @@ module.exports = (function() {
          if(dataType.references) {
            template += " REFERENCES " + this.quoteIdentifier(dataType.references)
            if(dataType.referencesKey) {
              template += " (" + this.quoteIdentifier(dataType.referencesKey) + ")"
            } else {
@@ -547,7 +552,7 @@ module.exports = (function() {
          }
          if (dataType.comment && Utils._.isString(dataType.comment) && dataType.comment.length) {
-            template += " COMMENT " + Utils.escape(dataType.comment)
+            template += " COMMENT " + this.escape(dataType.comment)
          }
          result[name] = template
@@ -594,12 +599,7 @@ module.exports = (function() {
    },
    escape: function(value) {
-      if (value instanceof Date) {
+      return SqlString.escape(value, false, null, "mysql")
-        value = Utils.toSqlDate(value)
-      } else if (typeof value === 'boolean') {
-        value = value ? 1 : 0
-      }
-      return Utils.escape(value)
    }
  }

--- a/lib/dialects/postgres/connector-manager.js
+++ b/lib/dialects/postgres/connector-manager.js
@@ -3,61 +3,76 @@ var Query   = require("./query")
 module.exports = (function() {
  var ConnectorManager = function(sequelize, config) {
+    var pgModule = config.dialectModulePath || 'pg'
    this.sequelize = sequelize
    this.client         = null
    this.config         = config || {}
    this.config.port    = this.config.port || 5432
-    this.pooling      = (!!this.config.poolCfg && (this.config.poolCfg.maxConnections > 0))
+    this.pooling        = (!!this.config.pool && (this.config.pool.maxConnections > 0))
-    this.pg           = this.config.native ? require('pg').native : require('pg')
+    this.pg             = this.config.native ? require(pgModule).native : require(pgModule)
+    this.poolIdentifier = null
+    // Better support for BigInts
+    // https://github.com/brianc/node-postgres/issues/166#issuecomment-9514935
+    this.pg.types.setTypeParser(20, String);
    // set pooling parameters if specified
    if (this.pooling) {
-      this.pg.defaults.poolSize        = this.config.poolCfg.maxConnections
+      this.pg.defaults.poolSize        = this.config.pool.maxConnections
-      this.pg.defaults.poolIdleTimeout = this.config.poolCfg.maxIdleTime
+      this.pg.defaults.poolIdleTimeout = this.config.pool.maxIdleTime
    }
    this.disconnectTimeoutId = null
    this.pendingQueries = 0
    this.maxConcurrentQueries = (this.config.maxConcurrentQueries || 50)
+    process.on('exit', function() {
+      this.disconnect()
+    }.bind(this))
  }
  Utils._.extend(ConnectorManager.prototype, require("../connector-manager").prototype)
-  var isConnecting = false
+  ConnectorManager.prototype.endQuery = function() {
-  var isConnected  = false
-  ConnectorManager.prototype.query = function(sql, callee, options) {
    var self = this
-    if (this.client === null) {
+    if (!self.pooling && self.pendingQueries === 0) {
-      this.connect()
+      setTimeout(function() {
+        self.pendingQueries === 0 && self.disconnect.call(self)
+      }, 100)
    }
-    var query = new Query(this.client, this.sequelize, 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() {
+  ConnectorManager.prototype.query = function(sql, callee, options) {
    var self = this
-    self.pendingQueries -= 1
-    if (self.pendingQueries == 0) {
+    self.pendingQueries++
-      setTimeout(function() {
-        self.pendingQueries == 0 && self.disconnect.call(self)
+    return new Utils.CustomEventEmitter(function(emitter) {
-      }, 100)
+      self.connect()
-    }
+      .on('error', function(err) {
+        emitter.emit('error', err)
+      })
+      .on('success', function(done) {
+        var query = new Query(self.client, self.sequelize, callee, options || {})
+        done = done || null
+        query.run(sql, done)
+          .success(function(results) { emitter.emit('success', results); self.endQuery.call(self) })
+          .error(function(err) { emitter.emit('error', err); self.endQuery.call(self) })
+          .on('sql', function(sql) { emitter.emit('sql', sql) })
+      })
+    }).run().complete(function() { self.pendingQueries-- })
  }
-  ConnectorManager.prototype.connect = function() {
+  ConnectorManager.prototype.connect = function(callback) {
    var self = this
    var emitter = new (require('events').EventEmitter)()
    // in case database is slow to connect, prevent orphaning the client
    if (this.isConnecting) {
-      return
+      emitter.emit('success')
+      return emitter
    }
    this.isConnecting = true
@@ -65,10 +80,14 @@ module.exports = (function() {
    var uri = this.sequelize.getQueryInterface().QueryGenerator.databaseConnectionUri(this.config)
-    var connectCallback = function(err, client) {
+    var connectCallback = function(err, client, done) {
      self.isConnecting = false
      if (!!err) {
+        // release the pool immediately, very important.
+        done && done(err)
+        if (err.code) {
          switch(err.code) {
          case 'ECONNREFUSED':
            emitter.emit('error', new Error("Failed to authenticate for PostgresSQL. Please double check your settings."))
@@ -80,21 +99,25 @@ module.exports = (function() {
            break
          default:
            emitter.emit('error', err)
+            break
+          }
        }
      } else if (client) {
-        client.query("SET TIME ZONE 'UTC'")
+        client.query("SET TIME ZONE 'UTC'").on('end', function() {
-          .on('end', function() {
            self.isConnected = true
-            this.client = client
+            self.client = client
+            emitter.emit('success', done)
          });
      } else {
-        this.client = null
+        self.client = null
+        emitter.emit('success', done)
      }
    }
    if (this.pooling) {
      // acquire client from pool
-      this.pg.connect(uri, connectCallback)
+      this.poolIdentifier = this.pg.pools.getOrCreate(this.sequelize.config)
+      this.poolIdentifier.connect(connectCallback)
    } else {
      //create one-off client
      this.client = new this.pg.Client(uri)
@@ -105,8 +128,14 @@ module.exports = (function() {
  }
  ConnectorManager.prototype.disconnect = function() {
-    var self = this
+    if (this.poolIdentifier) {
-    if (this.client) this.client.end()
+      this.poolIdentifier.destroyAllNow()
+    }
+    if (this.client) {
+      this.client.end()
+    }
    this.client = null
    this.isConnecting = false
    this.isConnected  = false

--- a/lib/dialects/postgres/query-generator.js
+++ b/lib/dialects/postgres/query-generator.js
 var Utils       = require("../../utils")
  , util        = require("util")
  , DataTypes   = require("../../data-types")
+  , SqlString   = require("../../sql-string")
  , tables      = {}
  , primaryKeys = {}
-  , moment      = require("moment")
 module.exports = (function() {
  var QueryGenerator = {
@@ -112,7 +112,7 @@ module.exports = (function() {
    },
    describeTableQuery: function(tableName) {
-      var query = 'SELECT c.column_name as "Field", c.column_default as "Default", c.is_nullable as "Null", c.data_type as "Type", (SELECT array_agg(e.enumlabel) FROM pg_catalog.pg_type t JOIN pg_catalog.pg_enum e ON t.oid=e.enumtypid WHERE t.typname=c.udt_name) AS special FROM information_schema.columns c WHERE table_name = <%= table %>;'
+      var query = 'SELECT c.column_name as "Field", c.column_default as "Default", c.is_nullable as "Null", c.data_type as "Type", (SELECT array_agg(e.enumlabel) FROM pg_catalog.pg_type t JOIN pg_catalog.pg_enum e ON t.oid=e.enumtypid WHERE t.typname=c.udt_name) AS "special" FROM information_schema.columns c WHERE table_name = <%= table %>;'
      return Utils._.template(query)({
        table: this.escape(tableName)
      })
@@ -293,7 +293,6 @@ module.exports = (function() {
      attrValueHash = Utils.removeNullValuesFromHash(attrValueHash, this.options.omitNull)
      var query     = "INSERT INTO <%= table %> (<%= attributes %>) VALUES (<%= values %>) RETURNING *;"
      // Remove serials that are null or undefined, which causes an error in PG
      Utils._.forEach(attrValueHash, function(value, key, hash) {
        if (tables[tableName]) {
@@ -725,10 +724,6 @@ module.exports = (function() {
      return (i < 10) ? '0' + i.toString() : i.toString()
    },
-    pgSqlDate: function (dt) {
-      return moment(dt).format("YYYY-MM-DD HH:mm:ss.SSS Z")
-    },
    pgDataTypeMapping: function (tableName, attr, dataType) {
      if (Utils._.includes(dataType, 'PRIMARY KEY')) {
        primaryKeys[tableName].push(attr)
@@ -779,33 +774,8 @@ module.exports = (function() {
      return identifiers.split('.').map(function(t) { return this.quoteIdentifier(t, force) }.bind(this)).join('.')
    },
-    escape: function (val, field) {
+    escape: function(value, field) {
-      if (val === undefined || val === null) {
+      return SqlString.escape(value, false, null, "postgres", field)
-        return 'NULL';
-      }
-      switch (typeof val) {
-        case 'boolean':
-          return (val) ? 'true' : 'false';
-        case 'number':
-          return val + '';
-        case 'object':
-          if (Array.isArray(val)) {
-            var ret = 'ARRAY['+ val.map(function(it) { return this.escape(it) }.bind(this)).join(',') + ']'
-            if (!!field && !!field.type) {
-              ret += '::' + field.type.replace(/\(\d+\)/g, '')
-            }
-            return ret
-          }
-      }
-      if (val instanceof Date) {
-        val = this.pgSqlDate(val);
-      }
-      // http://www.postgresql.org/docs/8.2/static/sql-syntax-lexical.html#SQL-SYNTAX-STRINGS
-      val = val.replace(/'/g, "''");
-      return "'" + val + "'";
    }
  }

--- a/lib/dialects/postgres/query.js
+++ b/lib/dialects/postgres/query.js
@@ -18,8 +18,9 @@ module.exports = (function() {
  }
  Utils.inherit(Query, AbstractQuery)
-  Query.prototype.run = function(sql) {
+  Query.prototype.run = function(sql, done) {
    this.sql = sql
+    var self = this
    if (this.options.logging !== false) {
      this.options.logging('Executing: ' + this.sql)
@@ -39,13 +40,14 @@ module.exports = (function() {
    }.bind(this))
    query.on('end', function() {
+      done && done()
      this.emit('sql', this.sql)
      if (receivedError) {
        return
      }
-      onSuccess.call(this, rows)
+      onSuccess.call(this, rows, sql)
    }.bind(this))
    return this
@@ -55,11 +57,11 @@ module.exports = (function() {
    return 'id'
  }
-  var onSuccess = function(rows) {
+  var onSuccess = function(rows, sql) {
    var results          = []
      , self             = this
-      , isTableNameQuery = (this.sql.indexOf('SELECT table_name FROM information_schema.tables') === 0)
+      , isTableNameQuery = (sql.indexOf('SELECT table_name FROM information_schema.tables') === 0)
-      , isRelNameQuery   = (this.sql.indexOf('SELECT relname FROM pg_class WHERE oid IN') === 0)
+      , isRelNameQuery   = (sql.indexOf('SELECT relname FROM pg_class WHERE oid IN') === 0)
    if (isTableNameQuery || isRelNameQuery) {
      if (isRelNameQuery) {
@@ -111,7 +113,7 @@ module.exports = (function() {
      } else {
        // Postgres will treat tables as case-insensitive, so fix the case
        // of the returned values to match attributes
-        if(this.sequelize.options.quoteIdentifiers == false) {
+        if(this.options.raw === false && this.sequelize.options.quoteIdentifiers === false) {
          var attrsMap = Utils._.reduce(this.callee.attributes, function(m, v, k) { m[k.toLowerCase()] = k; return m}, {})
          rows.forEach(function(row) {
            Utils._.keys(row).forEach(function(key) {

--- a/lib/dialects/query-generator.js
+++ b/lib/dialects/query-generator.js
@@ -289,7 +289,7 @@ module.exports = (function() {
      Escape a value (e.g. a string, number or date)
    */
    escape: function(value) {
-      throwMethodUndefined('quoteIdentifier')
+      throwMethodUndefined('escape')
    }
  }

--- a/lib/dialects/sqlite/connector-manager.js
+++ b/lib/dialects/sqlite/connector-manager.js
-var Utils   = require("../../utils")
+var sqlite3
-  , sqlite3 = require('sqlite3').verbose()
+  , Utils   = require("../../utils")
  , Query   = require("./query")
 module.exports = (function() {
-  var ConnectorManager = function(sequelize) {
+  var ConnectorManager = function(sequelize, config) {
    this.sequelize = sequelize
+    if (config.dialectModulePath) {
+      sqlite3 = require(config.dialectModulePath).verbose()
+    } else {
+      sqlite3 = require('sqlite3').verbose()
+    }
  }
  Utils._.extend(ConnectorManager.prototype, require("../connector-manager").prototype)
@@ -16,7 +22,7 @@ module.exports = (function() {
    this.database = db = new sqlite3.Database(self.sequelize.options.storage || ':memory:', function(err) {
      if (err) {
        if (err.code === "SQLITE_CANTOPEN") {
-          emitter.emit('error', new Error("Failed to find SQL server. Please double check your settings."))
+          emitter.emit('error', 'Failed to find SQL server. Please double check your settings.')
        }
      }

--- a/lib/dialects/sqlite/query-generator.js
+++ b/lib/dialects/sqlite/query-generator.js
 var Utils = require("../../utils")
  , DataTypes = require("../../data-types")
+  , SqlString = require("../../sql-string")
 var MySqlQueryGenerator = Utils._.extend(
  Utils._.clone(require("../query-generator")),
@@ -36,9 +37,8 @@ module.exports = (function() {
      return Utils._.template(query)({})
    },
-    dropSchema: function() {
+    dropSchema: function(tableName, options) {
-      var query = "SELECT name FROM sqlite_master WHERE type='table' and name!='sqlite_sequence';"
+      return this.dropTableQuery(tableName, options)
-      return Utils._.template(query)({})
    },
    showSchemasQuery: function() {
@@ -88,6 +88,16 @@ module.exports = (function() {
      return this.replaceBooleanDefaults(sql)
    },
+    dropTableQuery: function(tableName, options) {
+      options = options || {}
+      var query = "DROP TABLE IF EXISTS <%= table %>;"
+      return Utils._.template(query)({
+        table: this.quoteIdentifier(tableName)
+      })
+    },
    addColumnQuery: function() {
      var sql = MySqlQueryGenerator.addColumnQuery.apply(this, arguments)
      return this.replaceBooleanDefaults(sql)
@@ -133,6 +143,7 @@ module.exports = (function() {
      return Utils._.template(query)(replacements)
    },
    selectQuery: function(tableName, options) {
      var table = null,
          joinQuery = ""
@@ -188,8 +199,13 @@ module.exports = (function() {
        query += " ORDER BY " + options.order
      }
+      if (options.offset && !options.limit) {
-      if (options.limit && !(options.include && (options.limit === 1))) {
+        /*
+         * If no limit is defined, our best bet is to use the max number of rows in a table. From the SQLite docs:
+         * A 140 terabytes database can hold no more than approximately 1e+13 rows
+         */
+        query += " LIMIT " + options.offset + ", " + 10000000000000;
+      } else if (options.limit && !(options.include && (options.limit === 1))) {
        if (options.offset) {
          query += " LIMIT " + options.offset + ", " + options.limit
        } else {
@@ -372,7 +388,7 @@ module.exports = (function() {
    },
    removeIndexQuery: function(tableName, indexNameOrAttributes) {
-      var sql       = "DROP INDEX <%= indexName %>"
+      var sql       = "DROP INDEX IF EXISTS <%= indexName %>"
        , indexName = indexNameOrAttributes
      if (typeof indexName !== 'string') {
@@ -448,19 +464,7 @@ module.exports = (function() {
    },
    escape: function(value) {
-      if (value instanceof Date) {
+      return SqlString.escape(value, false, null, "sqlite")
-        value = Utils.toSqlDate(value)
-      }
-      if (typeof value === 'string') {
-        return "'" + value.replace(/'/g, "''") + "'";
-      } else if (typeof value === 'boolean') {
-        return value ? 1 : 0; // SQLite has no type boolean
-      } else if (value === null || value === undefined) {
-        return 'NULL';
-      } else {
-        return value;
-      }
    }
  }

--- a/lib/emitters/custom-event-emitter.js
+++ b/lib/emitters/custom-event-emitter.js
@@ -54,6 +54,12 @@ module.exports = (function() {
    return this
  }
+  CustomEventEmitter.prototype.sql =
+  function(fct) {
+    this.on('sql', bindToProcess(fct))
+    return this;
+  }
  // emit the events on the foreign emitter once events got triggered for me
  CustomEventEmitter.prototype.proxy = function(emitter) {
    proxyEventKeys.forEach(function (eventKey) {

--- a/lib/migration.js
+++ b/lib/migration.js
 var moment         = require("moment")
+  , path           = require("path")
  , Utils          = require("./utils")
  , DataTypes      = require("./data-types")
  , QueryInterface = require("./query-interface")
 module.exports = (function() {
-  var Migration = function(migrator, path) {
+  var Migration = function(migrator, p) {
    this.migrator       = migrator
-    this.path           = path
+    this.path           = path.normalize(p)
-    this.filename       = Utils._.last(this.path.split('/'))
+    this.filename       = Utils._.last(this.path.split(path.sep))
    var parsed          = Migration.parseFilename(this.filename)

--- a/lib/migrator.js
+++ b/lib/migrator.js
 const fs     = require("fs")
    , moment = require("moment")
-var Utils          = require("./utils")
+var Utils          = require(__dirname + "/utils")
-  , Migration      = require("./migration")
+  , Migration      = require(__dirname + "/migration")
-  , DataTypes      = require("./data-types")
+  , DataTypes      = require(__dirname + "/data-types")
 module.exports = (function() {
  var Migrator = function(sequelize, options) {
@@ -45,7 +45,7 @@ module.exports = (function() {
        if (err) {
          emitter.emit('error', err)
        } else {
-          var chainer = new Utils.QueryChainer
+          var chainer = new Utils.QueryChainer()
            , from    = migrations[0]
          if (options.method === 'down') {
@@ -177,6 +177,56 @@ module.exports = (function() {
    }).run()
  }
+  /**
+   * Explicitly executes one or multiple migrations.
+   *
+   * @param filename {String|Array} Absolute filename(s) of the migrations script
+   * @param options  {Object}       Can contain three functions, before, after and success, which are executed before
+   *                                or after each migration respectively, with one parameter, the migration.
+   */
+  Migrator.prototype.exec = function(filename, options) {
+    var self = this;
+    return new Utils.CustomEventEmitter(function(emitter) {
+      var chainer = new Utils.QueryChainer()
+      var addMigration = function(filename) {
+        self.options.logging('Adding migration script at ' + filename)
+        var migration = new Migration(self, filename)
+        chainer.add(migration, 'execute', [{ method: 'up' }], {
+          before: function(migration) {
+            if (options && Utils._.isFunction(options.before)) {
+              options.before.call(self, migration);
+            }
+          },
+          after: function(migration) {
+            if (options && Utils._.isFunction(options.after)) {
+              options.after.call(self, migration);
+            }
+          },
+          success: function(migration, callback) {
+            if (options && Utils._.isFunction(options.success)) {
+              options.success.call(self, migration);
+            }
+            callback();
+          }
+        })
+      }
+      if (Utils._.isArray(filename)) {
+        Utils._.each(filename, function(f) {
+          addMigration(f);
+        })
+      } else {
+        addMigration(filename);
+      }
+      chainer
+        .runSerially({ skipOnError: true })
+        .success(function() { emitter.emit('success', null) })
+        .error(function(err) { emitter.emit('error', err) })
+    }).run()
+  }
  // private
  var getLastMigrationFromDatabase = function() {

--- a/lib/query-chainer.js
+++ b/lib/query-chainer.js
-var Utils = require("./utils")
+var Utils = require(__dirname + "/utils")
 module.exports = (function() {
  var QueryChainer = function(emitters) {

--- a/lib/query-interface.js
+++ b/lib/query-interface.js
-var Utils                = require('./utils')
+var Utils                = require(__dirname + '/utils')
-  , DataTypes            = require('./data-types')
+  , DataTypes            = require(__dirname + '/data-types')
-  , SQLiteQueryInterface = require('./dialects/sqlite/query-interface')
+  , SQLiteQueryInterface = require(__dirname + '/dialects/sqlite/query-interface')
 module.exports = (function() {
  var QueryInterface = function(sequelize) {
@@ -54,7 +54,7 @@ module.exports = (function() {
      var showSchemasSql = self.QueryGenerator.showSchemasQuery()
      self.sequelize.query(showSchemasSql, null, { raw: true }).success(function(schemaNames) {
        self.emit('showAllSchemas', null)
-        emitter.emit('success', Utils._.flatten(Utils._.map(schemaNames, function(value){ return value.schema_name })))
+        emitter.emit('success', Utils._.flatten(Utils._.map(schemaNames, function(value){ return (!!value.schema_name ? value.schema_name : value) })))
      }).error(function(err) {
        self.emit('showAllSchemas', err)
        emitter.emit('error', err)
@@ -266,23 +266,128 @@ module.exports = (function() {
  }
  QueryInterface.prototype.update = function(dao, tableName, values, identifier) {
-    var sql = this.QueryGenerator.updateQuery(tableName, values, identifier)
+    var self = this
-    return queryAndEmit.call(this, [sql, dao], 'update')
+      , restrict = false
+      , sql = self.QueryGenerator.updateQuery(tableName, values, identifier)
+    // Check for a restrict field
+    if (!!dao.daoFactory && !!dao.daoFactory.associations) {
+      var keys = Object.keys(dao.daoFactory.associations)
+        , length = keys.length
+      for (var i = 0; i < length; i++) {
+        if (dao.daoFactory.associations[keys[i]].options && dao.daoFactory.associations[keys[i]].options.onUpdate && dao.daoFactory.associations[keys[i]].options.onUpdate === "restrict") {
+          restrict = true
+        }
+      }
+    }
+    return new Utils.CustomEventEmitter(function(emitter) {
+      var chainer = new Utils.QueryChainer()
+        chainer.add(self, 'enableForeignKeyConstraints', [])
+        chainer.add(self, 'queryAndEmit', [[sql, dao], 'delete'])
+      chainer.runSerially()
+      .success(function(results){
+        emitter.query = { sql: sql }
+        emitter.emit('success', results[1])
+        emitter.emit('sql', sql)
+      })
+      .error(function(err) {
+        emitter.query = { sql: sql }
+        emitter.emit('error', err)
+        emitter.emit('sql', sql)
+      })
+      .on('sql', function(sql) {
+        emitter.emit('sql', sql)
+      })
+    }).run()
  }
  QueryInterface.prototype.bulkUpdate = function(tableName, values, identifier) {
-    var sql = this.QueryGenerator.updateQuery(tableName, values, identifier)
+    var self = this
-    return queryAndEmit.call(this, sql, 'bulkUpdate')
+      , sql = self.QueryGenerator.updateQuery(tableName, values, identifier)
+    return new Utils.CustomEventEmitter(function(emitter) {
+      var chainer = new Utils.QueryChainer()
+      chainer.add(self, 'enableForeignKeyConstraints', [])
+      chainer.add(self, 'queryAndEmit', [sql, 'bulkUpdate'])
+      return chainer.runSerially()
+      .success(function(results){
+        emitter.query = { sql: sql }
+        emitter.emit('sql', sql)
+        emitter.emit('success', results[1])
+      })
+      .error(function(err) {
+        emitter.query = { sql: sql }
+        emitter.emit('sql', sql)
+        emitter.emit('error', err)
+      })
+    }).run()
  }
  QueryInterface.prototype.delete = function(dao, tableName, identifier) {
-    var sql = this.QueryGenerator.deleteQuery(tableName, identifier)
+    var self = this
-    return queryAndEmit.call(this, [sql, dao], 'delete')
+      , restrict = false
+      , sql = self.QueryGenerator.deleteQuery(tableName, identifier)
+    // Check for a restrict field
+    if (!!dao.daoFactory && !!dao.daoFactory.associations) {
+      var keys = Object.keys(dao.daoFactory.associations)
+        , length = keys.length
+      for (var i = 0; i < length; i++) {
+        if (dao.daoFactory.associations[keys[i]].options && dao.daoFactory.associations[keys[i]].options.onDelete && dao.daoFactory.associations[keys[i]].options.onDelete === "restrict") {
+          restrict = true
+        }
+      }
+    }
+    return new Utils.CustomEventEmitter(function(emitter) {
+      var chainer = new Utils.QueryChainer()
+        chainer.add(self, 'enableForeignKeyConstraints', [])
+        chainer.add(self, 'queryAndEmit', [[sql, dao], 'delete'])
+      chainer.runSerially()
+      .success(function(results){
+        emitter.query = { sql: sql }
+        emitter.emit('sql', sql)
+        emitter.emit('success', results[1])
+      })
+      .error(function(err) {
+        emitter.query = { sql: sql }
+        emitter.emit('sql', sql)
+        emitter.emit('error', err)
+      })
+    }).run()
  }
  QueryInterface.prototype.bulkDelete = function(tableName, identifier, options) {
-    var sql = this.QueryGenerator.deleteQuery(tableName, identifier, Utils._.defaults(options || {}, {limit: null}))
+    var self = this
-    return queryAndEmit.call(this, sql, 'bulkDelete')
+    var sql = self.QueryGenerator.deleteQuery(tableName, identifier, Utils._.defaults(options || {}, {limit: null}))
+    return new Utils.CustomEventEmitter(function(emitter) {
+      var chainer = new Utils.QueryChainer()
+      chainer.add(self, 'enableForeignKeyConstraints', [])
+      chainer.add(self, 'queryAndEmit', [sql, 'bulkDelete', options])
+      chainer.runSerially()
+      .success(function(results){
+        emitter.query = { sql: sql }
+        emitter.emit('sql', sql)
+        emitter.emit('success', results[1])
+      })
+      .error(function(err) {
+        emitter.query = { sql: sql }
+        emitter.emit('sql', sql)
+        emitter.emit('error', err)
+      })
+    }).run()
  }
  QueryInterface.prototype.select = function(factory, tableName, options, queryOptions) {
@@ -385,9 +490,7 @@ module.exports = (function() {
    return this.QueryGenerator.escape(value)
  }
-  // private
+  var queryAndEmit = QueryInterface.prototype.queryAndEmit = function(sqlOrQueryParams, methodName, options, emitter) {
-  var queryAndEmit = function(sqlOrQueryParams, methodName, options, emitter) {
    options = Utils._.extend({
      success: function(){},
      error: function(){}

--- a/lib/sequelize.js
+++ b/lib/sequelize.js
@@ -14,6 +14,7 @@ module.exports = (function() {
    @param {String} [password=null] The password which is used to authenticate against the database.
    @param {Object} [options={}] An object with options.
      @param {String} [options.dialect='mysql'] The dialect of the relational database.
+      @param {String} [options.dialectModulePath=null] If specified, load the dialect library from this path.
      @param {String} [options.host='localhost'] The host of the relational database.
      @param {Integer} [options.port=3306] The port of the relational database.
      @param {String} [options.protocol='tcp'] The protocol of the relational database.
@@ -68,6 +69,7 @@ module.exports = (function() {
    this.options = Utils._.extend({
      dialect: 'mysql',
+      dialectModulePath: null,
      host: 'localhost',
      protocol: 'tcp',
      define: {},
@@ -99,10 +101,15 @@ module.exports = (function() {
      queue   : this.options.queue,
      native  : this.options.native,
      replication: this.options.replication,
+      dialectModulePath: this.options.dialectModulePath,
      maxConcurrentQueries: this.options.maxConcurrentQueries
    }
+    try {
      var ConnectorManager = require("./dialects/" + this.options.dialect + "/connector-manager")
+    } catch(err) {
+      throw new Error("The dialect " + this.options.dialect + " is not supported.")
+    }
    this.daoFactoryManager = new DAOFactoryManager(this)
    this.connectorManager  = new ConnectorManager(this, this.config)
@@ -184,6 +191,7 @@ module.exports = (function() {
    var factory = new DAOFactory(daoName, attributes, options)
    this.daoFactoryManager.addDAO(factory.init(this.daoFactoryManager))
    return factory
  }

--- a/lib/sql-string.js
+++ b/lib/sql-string.js
-var SqlString = exports;
+var moment = require("moment")
+  , SqlString = exports;
 SqlString.escapeId = function (val, forbidQualified) {
  if (forbidQualified) {
@@ -7,18 +8,36 @@ SqlString.escapeId = function (val, forbidQualified) {
  return '`' + val.replace(/`/g, '``').replace(/\./g, '`.`') + '`';
 };
-SqlString.escape = function(val, stringifyObjects, timeZone, dialect) {
+SqlString.escape = function(val, stringifyObjects, timeZone, dialect, field) {
+  if (arguments.length === 1 && typeof arguments[0] === "object") {
+    val = val.val || val.value || null
+    stringifyObjects = val.stringifyObjects || val.objects || undefined
+    timeZone = val.timeZone || val.zone || null
+    dialect = val.dialect || null
+    field = val.field || null
+  }
+  else if (arguments.length < 3 && typeof arguments[1] === "object") {
+    timeZone = stringifyObjects.timeZone || stringifyObjects.zone || null
+    dialect = stringifyObjects.dialect || null
+    field = stringifyObjects.field || null
+  }
  if (val === undefined || val === null) {
    return 'NULL';
  }
  switch (typeof val) {
-    case 'boolean': return (val) ? 'true' : 'false';
+  case 'boolean':
-    case 'number': return val+'';
+    // SQLite doesn't have true/false support. MySQL aliases true/false to 1/0
+    // for us. Postgres actually has a boolean type with true/false literals,
+    // but sequelize doesn't use it yet.
+    return dialect === 'sqlite' ? +!!val : ('' + !!val);
+  case 'number':
+    return val+'';
  }
  if (val instanceof Date) {
-    val = SqlString.dateToString(val, timeZone || "Z");
+    val = SqlString.dateToString(val, timeZone || "Z", dialect);
  }
  if (Buffer.isBuffer(val)) {
@@ -26,7 +45,7 @@ SqlString.escape = function(val, stringifyObjects, timeZone, dialect) {
  }
  if (Array.isArray(val)) {
-    return SqlString.arrayToList(val, timeZone);
+    return SqlString.arrayToList(val, timeZone, dialect, field);
  }
  if (typeof val === 'object') {
@@ -37,8 +56,9 @@ SqlString.escape = function(val, stringifyObjects, timeZone, dialect) {
    }
  }
-  if (dialect == "postgres") {
+  if (dialect === 'postgres' || dialect === 'sqlite') {
    // http://www.postgresql.org/docs/8.2/static/sql-syntax-lexical.html#SQL-SYNTAX-STRINGS
+    // http://stackoverflow.com/q/603572/130598
    val = val.replace(/'/g, "''");
  } else {
    val = val.replace(/[\0\n\r\b\t\\\'\"\x1a]/g, function(s) {
@@ -56,11 +76,22 @@ SqlString.escape = function(val, stringifyObjects, timeZone, dialect) {
  return "'"+val+"'";
 };
-SqlString.arrayToList = function(array, timeZone) {
+SqlString.arrayToList = function(array, timeZone, dialect, field) {
+  if (dialect === 'postgres') {
+    var ret = 'ARRAY[' + array.map(function(v) {
+      return SqlString.escape(v, true, timeZone, dialect, field);
+    }).join(',') + ']';
+    if (!!field && !!field.type) {
+      ret += '::' + field.type.replace(/\(\d+\)/g, '');
+    }
+    return ret;
+  } else {
    return array.map(function(v) {
-    if (Array.isArray(v)) return '(' + SqlString.arrayToList(v) + ')';
+      if (Array.isArray(v))
-    return SqlString.escape(v, true, timeZone);
+        return '(' + SqlString.arrayToList(v, timeZone, dialect) + ')';
+      return SqlString.escape(v, true, timeZone, dialect);
    }).join(', ');
+  }
 };
 SqlString.format = function(sql, values, timeZone, dialect) {
@@ -75,10 +106,15 @@ SqlString.format = function(sql, values, timeZone, dialect) {
  });
 };
-SqlString.dateToString = function(date, timeZone) {
+SqlString.dateToString = function(date, timeZone, dialect) {
  var dt = new Date(date);
-  if (timeZone != 'local') {
+  // TODO: Ideally all dialects would work a bit more like this
+  if (dialect === "postgres") {
+    return moment(dt).zone('+00:00').format("YYYY-MM-DD HH:mm:ss.SSS Z");
+  }
+  if (timeZone !== 'local') {
    var tz = convertTimezone(timeZone);
    dt.setTime(dt.getTime() + (dt.getTimezoneOffset() * 60000));
@@ -87,14 +123,7 @@ SqlString.dateToString = function(date, timeZone) {
    }
  }
-  var year   = dt.getFullYear();
+  return moment(dt).format("YYYY-MM-DD HH:mm:ss");
-  var month  = zeroPad(dt.getMonth() + 1);
-  var day    = zeroPad(dt.getDate());
-  var hour   = zeroPad(dt.getHours());
-  var minute = zeroPad(dt.getMinutes());
-  var second = zeroPad(dt.getSeconds());
-  return year + '-' + month + '-' + day + ' ' + hour + ':' + minute + ':' + second;
 };
 SqlString.bufferToString = function(buffer) {

--- a/lib/utils.js
+++ b/lib/utils.js
 var util       = require("util")
  , DataTypes  = require("./data-types")
  , SqlString  = require("./sql-string")
+  , lodash     = require("lodash")
+  , _string    = require('underscore.string')
 var Utils = module.exports = {
  _: (function() {
-    var _  = require("lodash")
+    var _  = lodash
-      , _s = require('underscore.string')
+      , _s = _string
    _.mixin(_s.exports())
    _.mixin({
@@ -39,19 +41,216 @@ var Utils = module.exports = {
    var timeZone = null;
    return SqlString.format(arr.shift(), arr, timeZone, dialect)
  },
-  isHash: function(obj) {
+  // smartWhere can accept an array of {where} objects, or a single {where} object.
-    return Utils._.isObject(obj) && !Array.isArray(obj);
+  // The smartWhere function breaks down the collection of where objects into a more
+  // centralized object for each column so we can avoid duplicates
+  // e.g. WHERE username='dan' AND username='dan' becomes WHERE username='dan'
+  // All of the INs, NOT INs, BETWEENS, etc. are compressed into one key for each column
+  // This function will hopefully provide more functionality to sequelize in the future.
+  // tl;dr It's a nice way to dissect a collection of where objects and compress them into one object
+  smartWhere: function(whereArg, dialect) {
+    var self = this
+      , _where = {}
+      , logic
+      , type
+    (Array.isArray(whereArg) ? whereArg : [whereArg]).forEach(function(where) {
+      // If it's an array we're already good... / it's in a format that can't be broken down further
+      // e.g. Util.format['SELECT * FROM world WHERE status=?', 'hello']
+      if (Array.isArray(where)) {
+        _where._ = where._ || {queries: [], bindings: []}
+        _where._.queries[_where._.queries.length] = where[0]
+        if (where.length > 1) {
+          var values = where.splice(1)
+          if (dialect === "sqlite") {
+            values.forEach(function(v, i) {
+              if (typeof v === "boolean") {
+                values[i] = (v === true ? 1 : 0)
+              }
+            })
+          }
+          _where._.bindings = _where._.bindings.concat(values)
+        }
+      }
+      else if (typeof where === "object") {
+        // First iteration is trying to compress IN and NOT IN as much as possible...
+        // .. reason being is that WHERE username IN (?) AND username IN (?) != WHERE username IN (?,?)
+        Object.keys(where).forEach(function(i) {
+          if (Array.isArray(where[i])) {
+            where[i] = {
+              in: where[i]
+            }
+          }
+        })
+        // Build our smart object
+        Object.keys(where).forEach(function(i) {
+          type = typeof where[i]
+          _where[i] = _where[i] || {}
+          if (where[i] === null) {
+            // skip nulls
+          }
+          else if (Array.isArray(where[i])) {
+            _where[i].in = _where[i].in || []
+            _where[i].in.concat(where[i])
+          }
+          else if (type === "object") {
+            Object.keys(where[i]).forEach(function(ii) {
+              logic = self.getWhereLogic(ii)
+              switch(logic) {
+              case 'IN':
+                _where[i].in = _where[i].in || []
+                _where[i].in = _where[i].in.concat(where[i][ii]);
+                break
+              case 'NOT':
+                _where[i].not = _where[i].not || []
+                _where[i].not = _where[i].not.concat(where[i][ii]);
+                break
+              case 'BETWEEN':
+                _where[i].between = _where[i].between || []
+                _where[i].between[_where[i].between.length] = [where[i][ii][0], where[i][ii][1]]
+                break
+              case 'NOT BETWEEN':
+                _where[i].nbetween = _where[i].nbetween || []
+                _where[i].nbetween[_where[i].nbetween.length] = [where[i][ii][0], where[i][ii][1]]
+                break
+              case 'JOIN':
+                _where[i].joined = _where[i].joined || []
+                _where[i].joined[_where[i].joined.length] = where[i][ii]
+                break
+              default:
+                _where[i].lazy = _where[i].lazy || {conditions: [], bindings: []}
+                _where[i].lazy.conditions[_where[i].lazy.conditions.length] = logic + ' ?'
+                _where[i].lazy.bindings = _where[i].lazy.bindings.concat(where[i][ii])
+              }
+            })
+          }
+          else if (type === "string" || type === "number" || type === "boolean") {
+            _where[i].lazy = _where[i].lazy || {conditions: [], bindings: []}
+            if (type === "boolean") {
+              _where[i].lazy.conditions[_where[i].lazy.conditions.length] = '= ' + SqlString.escape(where[i], false, null, dialect) // sqlite is special
+            } else {
+              _where[i].lazy.conditions[_where[i].lazy.conditions.length] = '= ?'
+              _where[i].lazy.bindings = _where[i].lazy.bindings.concat(where[i])
+            }
+          }
+        })
+      }
+    })
+    return _where
+  },
+  // Converts {smart where} object(s) into an array that's friendly for Utils.format()
+  // NOTE: Must be applied/called from the QueryInterface
+  compileSmartWhere: function(obj, dialect) {
+    var self = this
+      , whereArgs = []
+      , text = []
+      , columnName
+    if (typeof obj !== "object") {
+      return obj
+    }
+    for (var column in obj) {
+      if (column === "_") {
+        text[text.length] = obj[column].queries.join(' AND ')
+        if (obj[column].bindings.length > 0) {
+          whereArgs = whereArgs.concat(obj[column].bindings)
+        }
+      } else {
+        Object.keys(obj[column]).forEach(function(condition) {
+          columnName = self.QueryInterface.quoteIdentifiers(column)
+          switch(condition) {
+          case 'in':
+            text[text.length] = columnName + ' IN (' + obj[column][condition].map(function(){ return '?' }) + ')'
+            whereArgs = whereArgs.concat(obj[column][condition])
+            break
+          case 'not':
+            text[text.length] = columnName + ' NOT IN (' + obj[column][condition].map(function(){ return '?' }) + ')'
+            whereArgs = whereArgs.concat(obj[column][condition])
+            break
+          case 'between':
+            Object.keys(obj[column][condition]).forEach(function(row) {
+              text[text.length] = columnName + ' BETWEEN ? AND ?'
+              whereArgs = whereArgs.concat(obj[column][condition][row][0], obj[column][condition][row][1])
+            })
+            break
+          case 'nbetween':
+            Object.keys(obj[column][condition]).forEach(function(row) {
+              text[text.length] = columnName + ' BETWEEN ? AND ?'
+              whereArgs = whereArgs.concat(obj[column][condition][row][0], obj[column][condition][row][1])
+            })
+            break
+          case 'joined':
+            Object.keys(obj[column][condition]).forEach(function(row) {
+              text[text.length] = columnName + ' = ' + self.QueryInterface.quoteIdentifiers(obj[column][condition][row])
+            })
+            break
+          default: // lazy
+            text = text.concat(obj[column].lazy.conditions.map(function(val){ return columnName + ' ' + val }))
+            obj[column].lazy.bindings = obj[column].lazy.bindings.map(function(v) { return SqlString.escape(v, false, null, dialect) })
+            whereArgs = whereArgs.concat(obj[column].lazy.bindings)
+          }
+        })
+      }
+    }
+    return lodash.compact([text.join(' AND ')].concat(whereArgs))
  },
-  pad: function (s) {
+  getWhereLogic: function(logic) {
-    return s < 10 ? '0' + s : s
+    switch (logic) {
+    case 'join':
+      return 'JOIN'
+    case 'gte':
+      return '>='
+      break
+    case 'gt':
+      return '>'
+      break
+    case 'lte':
+      return '<='
+      break
+    case 'lt':
+      return '<'
+      break
+    case 'eq':
+    case 'join':
+      return '='
+      break
+    case 'ne':
+      return '!='
+      break
+    case 'between':
+    case '..':
+      return 'BETWEEN'
+      break
+    case 'nbetween':
+    case 'notbetween':
+    case '!..':
+      return 'NOT BETWEEN'
+      break
+    case 'in':
+      return 'IN'
+      break
+    case 'not':
+      return 'NOT IN'
+      break
+    case 'like':
+      return 'LIKE'
+      break
+    case 'nlike':
+    case 'notlike':
+      return 'NOT LIKE'
+      break
+    default:
+      return ''
+    }
  },
-  toSqlDate: function(date) {
+  isHash: function(obj) {
-    return date.getUTCFullYear() + '-' +
+    return Utils._.isObject(obj) && !Array.isArray(obj);
-      this.pad(date.getUTCMonth()+1) + '-' +
-      this.pad(date.getUTCDate()) + ' ' +
-      this.pad(date.getUTCHours()) + ':' +
-      this.pad(date.getUTCMinutes()) + ':' +
-      this.pad(date.getUTCSeconds())
  },
  argsArePrimaryKeys: function(args, primaryKeys) {
    var result = (args.length == Object.keys(primaryKeys).length)
@@ -181,12 +380,9 @@ var Utils = module.exports = {
  removeTicks: function(s, tickChar) {
    tickChar = tickChar || Utils.TICK_CHAR
    return s.replace(new RegExp(tickChar, 'g'), "")
-  },
-  escape: function(s) {
-    return SqlString.escape(s, true, "local").replace(/\\"/g, '"')
  }
 }
-Utils.CustomEventEmitter = require("./emitters/custom-event-emitter")
+Utils.CustomEventEmitter = require(__dirname + "/emitters/custom-event-emitter")
-Utils.QueryChainer = require("./query-chainer")
+Utils.QueryChainer = require(__dirname + "/query-chainer")
 Utils.Lingo = require("lingo")
--- a/package.json
+++ b/package.json
@@ -22,6 +22,10 @@
        "janzeh@gmail.com",
        "jmei@itu.dk"
      ]
+    },
+    {
+      "name": "Daniel Durante",
+      "email": "me@danieldurante.com"
    }
  ],
  "repository": {
@@ -32,25 +36,28 @@
    "url": "https://github.com/sequelize/sequelize/issues"
  },
  "dependencies": {
-    "lodash": "~1.2.1",
+    "lodash": "~1.3.1",
    "underscore.string": "~2.3.0",
    "lingo": "~0.0.5",
-    "validator": "1.1.1",
+    "validator": "~1.3.0",
-    "moment": "~1.7.0",
+    "moment": "~2.1.0",
-    "commander": "~0.6.0",
+    "commander": "~1.3.0",
-    "dottie": "0.0.6-1",
+    "dottie": "0.0.8-0",
-    "toposort-class": "0.1.4",
+    "toposort-class": "~0.2.0",
    "generic-pool": "2.0.3",
-    "promise": "~3.0.0"
+    "promise": "~3.2.0"
  },
  "devDependencies": {
-    "jasmine-node": "1.5.0",
+    "sqlite3": "~2.1.12",
-    "sqlite3": "~2.1.5",
+    "mysql": "~2.0.0-alpha8",
-    "mysql": "~2.0.0-alpha7",
+    "pg": "~2.2.0",
-    "pg": "~2.0.0",
    "buster": "~0.6.3",
-    "watchr": "~2.2.0",
+    "watchr": "~2.4.3",
-    "yuidocjs": "~0.3.36"
+    "yuidocjs": "~0.3.36",
+    "chai": "~1.7.2",
+    "mocha": "~1.12.0",
+    "chai-datetime": "~1.0.0",
+    "sinon": "~1.7.3"
  },
  "keywords": [
    "mysql",
@@ -60,14 +67,7 @@
  ],
  "main": "index",
  "scripts": {
-    "test": "npm run test-jasmine && npm run test-buster",
+    "test": "make all",
-    "test-jasmine": "jasmine-node spec-jasmine/",
-    "test-buster": "npm run test-buster-mysql && npm run test-buster-postgres && npm run test-buster-postgres-native && npm run test-buster-sqlite",
-    "test-buster-travis": "buster-test",
-    "test-buster-mysql": "DIALECT=mysql buster-test",
-    "test-buster-postgres": "DIALECT=postgres buster-test",
-    "test-buster-postgres-native": "DIALECT=postgres-native buster-test",
-    "test-buster-sqlite": "DIALECT=sqlite buster-test",
    "docs": "node_modules/.bin/yuidoc . -o docs"
  },
  "bin": {

--- a/spec-jasmine/assets/migrations/20111117063700-createPerson.js
+++ b/spec-jasmine/assets/migrations/20111117063700-createPerson.js
-module.exports = {
-  up: function(migration, DataTypes) {
-    migration.createTable('Person', {
-      name: DataTypes.STRING,
-      isBetaMember: {
-        type: DataTypes.BOOLEAN,
-        defaultValue: false,
-        allowNull: false
-      }
-    })
-  },
-  down: function(migration) {
-    migration.dropTable('Person')
-  }
-}
--- a/spec-jasmine/assets/migrations/20111130161100-emptyMigration.js
+++ b/spec-jasmine/assets/migrations/20111130161100-emptyMigration.js
-module.exports = {
-  up: function() {},
-  down: function() {}
-}
--- a/spec-jasmine/assets/migrations/20111205064000-renamePersonToUser.js
+++ b/spec-jasmine/assets/migrations/20111205064000-renamePersonToUser.js
-module.exports = {
-  up: function(migration, DataTypes) {
-    migration.renameTable('Person', 'User')
-  },
-  down: function(migration, DataTypes) {
-    migration.renameTable('User', 'Person')
-  }
-}
--- a/spec-jasmine/assets/migrations/20111205162700-addSignatureColumnToUser.js
+++ b/spec-jasmine/assets/migrations/20111205162700-addSignatureColumnToUser.js
-module.exports = {
-  up: function(migration, DataTypes) {
-    migration.addColumn('User', 'signature', DataTypes.TEXT)
-    migration.addColumn('User', 'shopId', { type: DataTypes.INTEGER, allowNull: true })
-    migration.addColumn('User', 'isAdmin', { type: DataTypes.BOOLEAN, defaultValue: false, allowNull: false })
-  },
-  down: function(migration, DataTypes) {
-    migration.removeColumn('User', 'signature')
-    migration.removeColumn('User', 'shopId')
-    migration.removeColumn('User', 'isAdmin')
-  }
-}
--- a/spec-jasmine/assets/migrations/20111206061400-removeShopIdColumnFromUser.js
+++ b/spec-jasmine/assets/migrations/20111206061400-removeShopIdColumnFromUser.js
-module.exports = {
-  up: function(migration, DataTypes) {
-    migration.removeColumn('User', 'shopId')
-  },
-  down: function(migration, DataTypes) {
-    migration.addColumn('User', 'shopId', { type: DataTypes.INTEGER, allowNull: true })
-  }
-}
--- a/spec-jasmine/assets/migrations/20111206063000-changeSignatureColumnOfUserToMendatory.js
+++ b/spec-jasmine/assets/migrations/20111206063000-changeSignatureColumnOfUserToMendatory.js
-module.exports = {
-  up: function(migration, DataTypes) {
-    migration.changeColumn('User', 'signature', {
-      type: DataTypes.STRING,
-      allowNull: false,
-      defaultValue: 'Signature'
-    })
-  },
-  down: function(migration, DataTypes) {}
-}
--- a/spec-jasmine/assets/migrations/20111206163300-renameSignatureColumnOfUserToSig.js
+++ b/spec-jasmine/assets/migrations/20111206163300-renameSignatureColumnOfUserToSig.js
-module.exports = {
-  up: function(migration, DataTypes) {
-    migration.renameColumn('User', 'signature', 'sig')
-  },
-  down: function(migration, DataTypes) {
-    migration.renameColumn('User', 'sig', 'signature')
-  }
-}
--- a/spec-jasmine/associations/belongs-to.spec.js
+++ b/spec-jasmine/associations/belongs-to.spec.js
-var config    = require("../config/config")
-  , Sequelize = require("../../index")
-  , sequelize = new Sequelize(config.mysql.database, config.mysql.username, config.mysql.password, { pool: config.mysql.pool, logging: false, host: config.mysql.host, port: config.mysql.port })
-  , Helpers   = new (require("../config/helpers"))(sequelize)
-describe('BelongsTo', function() {
-  var User = null
-    , Task = null
-  var setup = function() {
-    User = sequelize.define('User', { username: Sequelize.STRING, enabled: {
-      type: Sequelize.BOOLEAN,
-      defaultValue: true
-    }})
-    Task = sequelize.define('Task', { title: Sequelize.STRING })
-  }
-  beforeEach(function() { Helpers.dropAllTables(); setup() })
-  afterEach(function() { Helpers.dropAllTables() })
-  it('adds the foreign key', function() {
-    Task.belongsTo(User)
-    expect(Task.attributes['UserId']).toEqual("INTEGER")
-  })
-  it("underscores the foreign key", function() {
-    Task = sequelize.define('Task', { title: Sequelize.STRING }, {underscored: true})
-    Task.belongsTo(User)
-    expect(Task.attributes['user_id']).toEqual("INTEGER")
-  })
-  it("uses the passed foreign key", function() {
-    Task.belongsTo(User, {foreignKey: 'person_id'})
-    expect(Task.attributes['person_id']).toEqual("INTEGER")
-  })
-  it("defines getters and setters", function() {
-    Task.belongsTo(User)
-    var task = Task.build({title: 'asd'})
-    expect(task.setUser).toBeDefined()
-    expect(task.getUser).toBeDefined()
-  })
-  it("aliases the getters and setters according to the passed 'as' option", function() {
-    Task.belongsTo(User, {as: 'Person'})
-    var task = Task.build({title: 'asd'})
-    expect(task.setPerson).toBeDefined()
-    expect(task.getPerson).toBeDefined()
-  })
-  it("aliases associations to the same table according to the passed 'as' option", function() {
-    Task.belongsTo(User, {as: 'Poster'})
-    Task.belongsTo(User, {as: 'Owner'})
-    var task = Task.build({title: 'asd'})
-    expect(task.getPoster).toBeDefined()
-    expect(task.setPoster).toBeDefined()
-    expect(task.getOwner).toBeDefined()
-    expect(task.setOwner).toBeDefined()
-  })
-  it("intializes the foreign key with null", function() {
-    Task.belongsTo(User)
-    var task = Task.build({title: 'asd'})
-    expect(task['UserId']).not.toBeDefined();
-  })
-  it("sets and gets the correct objects", function() {
-    Task.belongsTo(User, {as: 'User'})
-    Helpers.async(function(done) {
-      User.sync({force: true}).success(function() {
-        Task.sync({force: true}).success(done)
-      })
-    })
-    Helpers.async(function(done) {
-      User.create({username: 'asd'}).success(function(u) {
-        Task.create({title: 'a task'}).success(function(t) {
-          t.setUser(u).success(function() {
-            t.getUser().success(function(user) {
-              expect(user.username).toEqual('asd')
-              done()
-            })
-          })
-        })
-      })
-    })
-  })
-  it('extends the id where param with the supplied where params', function() {
-    Task.belongsTo(User, {as: 'User'})
-    Helpers.async(function(done) {
-      User.sync({force: true}).success(function() {
-        Task.sync({force: true}).success(done)
-      })
-    })
-    Helpers.async(function(done) {
-      User.create({username: 'asd', enabled: false}).success(function(u) {
-        Task.create({title: 'a task'}).success(function(t) {
-          t.setUser(u).success(function() {
-            t.getUser({where: {enabled: true}}).success(function(user) {
-              expect(user).toEqual(null)
-              done()
-            })
-          })
-        })
-      })
-    })
-  })
-  it("handles self associations", function() {
-    Helpers.async(function(done) {
-      var Person = sequelize.define('Person', { name: Sequelize.STRING })
-      Person.belongsTo(Person, {as: 'Mother', foreignKey: 'MotherId'})
-      Person.belongsTo(Person, {as: 'Father', foreignKey: 'FatherId'})
-      Person.sync({force: true}).success(function() {
-        var p = Person.build()
-        expect(p.setFather).toBeDefined()
-        expect(p.setMother).toBeDefined()
-        done()
-      })
-    })
-  })
-  it("sets the foreign key in self associations", function() {
-    var Person = sequelize.define('Person', { name: Sequelize.STRING })
-    Person.belongsTo(Person, {as: 'Mother'})
-    expect(Person.associations.MotherPersons.options.foreignKey).toEqual('MotherId')
-  })
-})
--- a/spec-jasmine/associations/has-many.spec.js
+++ b/spec-jasmine/associations/has-many.spec.js
--- a/spec-jasmine/associations/has-one.spec.js
+++ b/spec-jasmine/associations/has-one.spec.js
-var config    = require("../config/config")
-  , Sequelize = require("../../index")
-  , sequelize = new Sequelize(config.mysql.database, config.mysql.username, config.mysql.password, { pool: config.mysql.pool, logging: false, host: config.mysql.host, port: config.mysql.port })
-  , Helpers   = new (require("../config/helpers"))(sequelize)
-describe('HasOne', function() {
-  var User = null
-    , Task = null
-  var setup = function() {
-    User = sequelize.define('User', { username: Sequelize.STRING })
-    Task = sequelize.define('Task', { title: Sequelize.STRING })
-  }
-  beforeEach(function() { Helpers.dropAllTables(); setup() })
-  afterEach(function() { Helpers.dropAllTables() })
-  it("adds the foreign key", function() {
-    User.hasOne(Task)
-    expect(Task.attributes.UserId).toEqual("INTEGER")
-  })
-  it("adds an underscored foreign key", function() {
-    User = sequelize.define('User', { username: Sequelize.STRING }, {underscored: true})
-    Task = sequelize.define('Task', { title: Sequelize.STRING })
-    User.hasOne(Task)
-    expect(Task.attributes.user_id).toEqual("INTEGER")
-  })
-  it("uses the passed foreign key", function() {
-    User = sequelize.define('User', { username: Sequelize.STRING }, {underscored: true})
-    Task = sequelize.define('Task', { title: Sequelize.STRING })
-    User.hasOne(Task, {foreignKey: 'person_id'})
-    expect(Task.attributes.person_id).toEqual("INTEGER")
-  })
-  it("defines the getter and the setter", function() {
-    User.hasOne(Task)
-    var u = User.build({username: 'asd'})
-    expect(u.setTask).toBeDefined()
-    expect(u.getTask).toBeDefined()
-  })
-  it("defined the getter and the setter according to the passed 'as' option", function() {
-    User.hasOne(Task, {as: 'Work'})
-    var u = User.build({username: 'asd'})
-    expect(u.setWork).toBeDefined()
-    expect(u.getWork).toBeDefined()
-  })
-  it("aliases associations to the same table according to the passed 'as' option", function() {
-      User.hasOne(Task, {as: 'Work'});
-      User.hasOne(Task, {as: 'Play'});
-      var u = User.build({username: 'asd'})
-      expect(u.getWork).toBeDefined()
-      expect(u.setWork).toBeDefined()
-      expect(u.getPlay).toBeDefined()
-      expect(u.setPlay).toBeDefined()
-  })
-  it("gets and sets the correct objects", function() {
-    var user, task;
-    User.hasOne(Task, {as: 'Task'})
-    Helpers.async(function(done) {
-      User.sync({force: true}).success(function() {
-        Task.sync({force: true}).success(function() {
-          User.create({username: 'name'}).success(function(_user) {
-            Task.create({title: 'snafu'}).success(function(_task) {
-              user = _user
-              task = _task
-              done()
-            })
-          })
-        })
-      })
-    })
-    Helpers.async(function(done) {
-      user.setTask(task).on('success', function() {
-        user.getTask().on('success', function(task2) {
-          expect(task.title).toEqual(task2.title)
-          user.getTask({attributes: ['title']}).on('success', function(task2) {
-            expect(task2.selectedValues.title).toEqual('snafu')
-            expect(task2.selectedValues.id).toEqual(null)
-            done()
-          })
-        })
-      })
-    })
-  })
-  it("unsets unassociated objects", function() {
-    var user, task1, task2;
-    User.hasOne(Task, {as: 'Task'})
-    Helpers.async(function(done) {
-      User.sync({force: true}).success(function() {
-        Task.sync({force: true}).success(function() {
-          User.create({username: 'name'}).success(function(_user) {
-            Task.create({title: 'snafu'}).success(function(_task1) {
-              Task.create({title: 'another task'}).success(function(_task2) {
-                user  = _user
-                task1 = _task1
-                task2 = _task2
-                done()
-              })
-            })
-          })
-        })
-      })
-    })
-    Helpers.async(function(done) {
-      user.setTask(task1).success(function() {
-        user.getTask().success(function(_task) {
-          expect(task1.title).toEqual(_task.title)
-          user.setTask(task2).success(function() {
-            user.getTask().success(function(_task2) {
-              expect(task2.title).toEqual(task2.title)
-              done()
-            })
-          })
-        })
-      })
-    })
-  })
-  it("sets self associations", function() {
-    Helpers.async(function(done) {
-      var Person = sequelize.define('Person', { name: Sequelize.STRING })
-      Person.hasOne(Person, {as: 'Mother', foreignKey: 'MotherId'})
-      Person.hasOne(Person, {as: 'Father', foreignKey: 'FatherId'})
-      Person.sync({force: true}).success(function() {
-        var p = Person.build()
-        expect(p.setFather).toBeDefined()
-        expect(p.setMother).toBeDefined()
-        done()
-      })
-    })
-  })
-  it("automatically sets the foreign key on self associations", function() {
-    var Person = sequelize.define('Person', { name: Sequelize.STRING })
-    Person.hasOne(Person, {as: 'Mother'})
-    expect(Person.associations.MotherPersons.options.foreignKey).toEqual('MotherId')
-  })
-})
--- a/spec-jasmine/config/config.js
+++ b/spec-jasmine/config/config.js
-module.exports = {
-  rand: function() {
-    return parseInt(Math.random() * 999)
-  },
-  //make maxIdleTime small so that tests exit promptly
-  mysql: {
-    username: "root",
-    password: null,
-    database: 'sequelize_test',
-    host: '127.0.0.1',
-    port: 3306,
-    pool: { maxConnections: 5, maxIdleTime: 30}
-  },
-  sqlite: {
-  },
-  postgres: {
-    database: 'sequelize_test',
-    username: "postgres",
-    port: 5432,
-    pool: { maxConnections: 5, maxIdleTime: 30}
-  }
-}
--- a/spec-jasmine/config/factories.js
+++ b/spec-jasmine/config/factories.js
-var Factories = module.exports = function(helpers) {
-  this.helpers = helpers
-  this.sequelize = this.helpers.sequelize
-}
-Factories.prototype.DAO = function(daoName, options, callback, count) {
-  count = count || 1
-  var self   = this
-    , daos = []
-  this.helpers.async(function(done) {
-    var DAO  = self.sequelize.daoFactoryManager.getDAO(daoName)
-    var create = function(cb) {
-      DAO.create(options).on('success', function(dao) {
-        daos.push(dao)
-        cb && cb()
-      }).on('error', function(err) {
-        console.log(err)
-        done()
-      })
-    }
-    var cb = function() {
-      if(--count) {
-        create(cb)
-      } else {
-        done()
-        callback && callback(daos)
-      }
-    }
-    create(cb)
-  })
-}
-Factories.prototype.User = function(options, callback, count) {
-  this.DAO('User', options, callback, count)
-}
--- a/spec-jasmine/config/helpers.js
+++ b/spec-jasmine/config/helpers.js
-Sequelize = require("../../index")
-var Helpers = module.exports = function(sequelize) {
-  this.sequelize = sequelize
-  this.Factories = new (require("./factories"))(this)
-}
-Helpers.prototype.sync = function() {
-  var self = this
-  this.async(function(done) {
-    self.sequelize
-      .sync({force: true})
-      .success(done)
-      .failure(function(err) { console.log(err) })
-  })
-}
-Helpers.prototype.drop = function() {
-  var self = this
-  this.async(function(done) {
-    self.sequelize
-      .drop()
-      .on('success', done)
-      .on('error', function(err) { console.log(err) })
-  })
-}
-Helpers.prototype.dropAllTables = function() {
-  var self = this
-  this.async(function(done) {
-    self.sequelize
-      .getQueryInterface()
-      .dropAllTables()
-      .success(done)
-      .error(function(err) { console.log(err) })
-  })
-}
-Helpers.prototype.async = function(fct) {
-  var done = false
-  runs(function() {
-    fct(function() { return done = true })
-  })
-  waitsFor(function(){ return done })
-}
--- a/spec-jasmine/dao-factory.spec.js
+++ b/spec-jasmine/dao-factory.spec.js
--- a/spec-jasmine/dao.spec.js
+++ b/spec-jasmine/dao.spec.js
--- a/spec-jasmine/mysql/associations.has-many.spec.js
+++ b/spec-jasmine/mysql/associations.has-many.spec.js
-var config    = require("../config/config")
-  , Sequelize = require("../../index")
-  , sequelize = new Sequelize(config.mysql.database, config.mysql.username, config.mysql.password, { pool: config.mysql.pool, logging: false, host: config.mysql.host, port: config.mysql.port })
-  , Helpers   = new (require("../config/helpers"))(sequelize)
-describe('HasMany', function() {
-  beforeEach(function() { Helpers.sync() })
-  afterEach(function() { Helpers.drop() })
-  //prevent periods from occurring in the table name since they are used to delimit (table.column)
-  var User  = sequelize.define('User' + Math.ceil(Math.random()*10000000), { name: Sequelize.STRING })
-    , Task  = sequelize.define('Task' + Math.ceil(Math.random()*10000000), { name: Sequelize.STRING })
-    , users = null
-    , tasks = null
-  User.hasMany(Task, {as:'Tasks'})
-  Task.hasMany(User, {as:'Users'})
-  beforeEach(function() {
-    Helpers.async(function(_done) {
-      Helpers.Factories.DAO(User.name, {name: 'User' + Math.random()}, function(_users) {
-        users = _users; _done()
-      }, 5)
-    })
-    Helpers.async(function(_done) {
-      Helpers.Factories.DAO(Task.name, {name: 'Task' + Math.random()}, function(_tasks) {
-        tasks = _tasks; _done()
-      }, 2)
-    })
-  })
-  describe('addDAO / getDAO', function() {
-    var user = null
-      , task = null
-    beforeEach(function() {
-      Helpers.async(function(done) {
-        User.all().on('success', function(_users) {
-          Task.all().on('success', function(_tasks) {
-            user = _users[0]
-            task = _tasks[0]
-            done()
-          })
-        })
-      })
-    })
-    it('should correctly add an association to the dao', function() {
-      Helpers.async(function(done) {
-        user.getTasks().on('success', function(_tasks) {
-          expect(_tasks.length).toEqual(0)
-          user.addTask(task).on('success', function() {
-            user.getTasks().on('success', function(_tasks) {
-              expect(_tasks.length).toEqual(1)
-              done()
-            })
-          })
-        })
-      })
-    })
-  })
-  describe('removeDAO', function() {
-    var user  = null
-      , tasks = null
-    beforeEach(function() {
-      Helpers.async(function(done) {
-        User.all().on('success', function(users) {
-          Task.all().on('success', function(_tasks) {
-            user = users[0]
-            tasks = _tasks
-            done()
-          })
-        })
-      })
-    })
-    it("should correctly remove associated objects", function() {
-      Helpers.async(function(done) {
-        user.getTasks().on('success', function(__tasks) {
-          expect(__tasks.length).toEqual(0)
-          user.setTasks(tasks).on('success', function() {
-            user.getTasks().on('success', function(_tasks) {
-              expect(_tasks.length).toEqual(tasks.length)
-              user.removeTask(tasks[0]).on('success', function() {
-                user.getTasks().on('success', function(_tasks) {
-                  expect(_tasks.length).toEqual(tasks.length - 1)
-                  done()
-                })
-              })
-            })
-          })
-        })
-      })
-    })
-  })
-})
--- a/spec-jasmine/mysql/associations.spec.js
+++ b/spec-jasmine/mysql/associations.spec.js
-var config    = require("../config/config")
-  , Sequelize = require("../../index")
-  , sequelize = new Sequelize(config.mysql.database, config.mysql.username, config.mysql.password, { pool: config.mysql.pool, logging: false, host: config.mysql.host, port: config.mysql.port })
-  , Helpers   = new (require("../config/helpers"))(sequelize)
-describe('Associations', function() {
-  beforeEach(function() { Helpers.sync() })
-  afterEach(function() { Helpers.drop() })
-  /////////// many-to-many with same prefix ////////////
-  describe('many-to-many', function() {
-    describe('where tables have the same prefix', function() {
-      var Table2 = sequelize.define('wp_table2', {foo: Sequelize.STRING})
-        , Table1 = sequelize.define('wp_table1', {foo: Sequelize.STRING})
-      Table1.hasMany(Table2)
-      Table2.hasMany(Table1)
-      it("should create a table wp_table1wp_table2s", function() {
-        Helpers.async(function(done) {
-          expect(sequelize.daoFactoryManager.getDAO('wp_table1swp_table2s')).toBeDefined()
-          done()
-        })
-      })
-    })
-    describe('when join table name is specified', function() {
-      var Table2 = sequelize.define('ms_table1', {foo: Sequelize.STRING})
-        , Table1 = sequelize.define('ms_table2', {foo: Sequelize.STRING})
-      Table1.hasMany(Table2, {joinTableName: 'table1_to_table2'})
-      Table2.hasMany(Table1, {joinTableName: 'table1_to_table2'})
-      it("should not use a combined name", function() {
-        expect(sequelize.daoFactoryManager.getDAO('ms_table1sms_table2s')).toBeUndefined()
-      })
-      it("should use the specified name", function() {
-        expect(sequelize.daoFactoryManager.getDAO('table1_to_table2')).toBeDefined()
-      })
-    })
-  })
-})
--- a/spec-jasmine/mysql/connector-manager.spec.js
+++ b/spec-jasmine/mysql/connector-manager.spec.js
-var config    = require("../config/config")
-  , Sequelize = require("../../index")
-  , sequelize = new Sequelize(config.mysql.database, config.mysql.username, config.mysql.password, { pool: config.mysql.pool, logging: false, host: config.mysql.host, port: config.mysql.port })
-  , Helpers   = new (require("../config/helpers"))(sequelize)
-describe('ConnectorManager', function() {
-  beforeEach(function() {
-    Helpers.dropAllTables()
-  })
-  afterEach(function() {
-    Helpers.dropAllTables()
-  })
-  it('works correctly after being idle', function() {
-    var User = sequelize.define('User', { username: Sequelize.STRING })
-    Helpers.async(function(done) {
-      User.sync({force: true}).on('success', function() {
-        User.create({username: 'user1'}).on('success', function() {
-          User.count().on('success', function(count) {
-            expect(count).toEqual(1)
-            done()
-          })
-        })
-      })
-    })
-    Helpers.async(function(done) {
-      setTimeout(function() {
-        User.count().on('success', function(count) {
-          expect(count).toEqual(1)
-          done()
-        })
-      }, 1000)
-    })
-  })
-})
--- a/spec-jasmine/mysql/dao-factory.spec.js
+++ b/spec-jasmine/mysql/dao-factory.spec.js
-var config    = require("../config/config")
-  , Sequelize = require("../../index")
-  , sequelize = new Sequelize(config.mysql.database, config.mysql.username, config.mysql.password, { pool: config.mysql.pool, logging: false, host: config.mysql.host, port: config.mysql.port })
-  , Helpers   = new (require("../config/helpers"))(sequelize)
-describe('DAOFactory', function() {
-  beforeEach(function() { Helpers.sync() })
-  afterEach(function() { Helpers.drop() })
-  var User = sequelize.define('User', { age: Sequelize.INTEGER, name: Sequelize.STRING, bio: Sequelize.TEXT })
-  describe('constructor', function() {
-    it("handles extended attributes (unique)", function() {
-      var User = sequelize.define('User' + config.rand(), {
-        username: { type: Sequelize.STRING, unique: true }
-      }, { timestamps: false })
-      expect(User.attributes).toEqual({username:"VARCHAR(255) UNIQUE",id:"INTEGER NOT NULL auto_increment PRIMARY KEY"})
-    })
-    it("handles extended attributes (default)", function() {
-      var User = sequelize.define('User' + config.rand(), {
-        username: {type: Sequelize.STRING, defaultValue: 'foo'}
-      }, { timestamps: false })
-      expect(User.attributes).toEqual({username:"VARCHAR(255) DEFAULT 'foo'",id:"INTEGER NOT NULL auto_increment PRIMARY KEY"})
-    })
-    it("handles extended attributes (null)", function() {
-      var User = sequelize.define('User' + config.rand(), {
-        username: {type: Sequelize.STRING, allowNull: false}
-      }, { timestamps: false })
-      expect(User.attributes).toEqual({username:"VARCHAR(255) NOT NULL",id:"INTEGER NOT NULL auto_increment PRIMARY KEY"})
-    })
-    it("handles extended attributes (comment)", function() {
-      var User = sequelize.define('User' + config.rand(), {
-        username: {type: Sequelize.STRING, comment: 'This be\'s a comment'}
-      }, { timestamps: false })
-      expect(User.attributes).toEqual({username:"VARCHAR(255) COMMENT 'This be\\'s a comment'",id:"INTEGER NOT NULL auto_increment PRIMARY KEY"})
-    })
-    it("handles extended attributes (primaryKey)", function() {
-      var User = sequelize.define('User' + config.rand(), {
-        username: {type: Sequelize.STRING, primaryKey: true}
-      }, { timestamps: false })
-      expect(User.attributes).toEqual({username:"VARCHAR(255) PRIMARY KEY"})
-    })
-    it("adds timestamps", function() {
-      var User1 = sequelize.define('User' + config.rand(), {})
-      var User2 = sequelize.define('User' + config.rand(), {}, { timestamps: true })
-      expect(User1.attributes).toEqual({id:"INTEGER NOT NULL auto_increment PRIMARY KEY", updatedAt:"DATETIME NOT NULL", createdAt:"DATETIME NOT NULL"})
-      expect(User2.attributes).toEqual({id:"INTEGER NOT NULL auto_increment PRIMARY KEY", updatedAt:"DATETIME NOT NULL", createdAt:"DATETIME NOT NULL"})
-    })
-    it("adds deletedAt if paranoid", function() {
-      var User = sequelize.define('User' + config.rand(), {}, { paranoid: true })
-      expect(User.attributes).toEqual({id:"INTEGER NOT NULL auto_increment PRIMARY KEY", deletedAt:"DATETIME", updatedAt:"DATETIME NOT NULL", createdAt:"DATETIME NOT NULL"})
-    })
-    it("underscores timestamps if underscored", function() {
-      var User = sequelize.define('User' + config.rand(), {}, { paranoid: true, underscored: true })
-      expect(User.attributes).toEqual({id:"INTEGER NOT NULL auto_increment PRIMARY KEY", deleted_at:"DATETIME", updated_at:"DATETIME NOT NULL", created_at:"DATETIME NOT NULL"})
-    })
-  })
-  describe('primaryKeys', function() {
-    it("determines the correct primaryKeys", function() {
-      var User = sequelize.define('User' + config.rand(), {
-        foo: {type: Sequelize.STRING, primaryKey: true},
-        bar: Sequelize.STRING
-      })
-      expect(User.primaryKeys).toEqual({"foo":"VARCHAR(255) PRIMARY KEY"})
-    })
-  })
-})
--- a/spec-jasmine/postgres/associations.has-many.spec.js
+++ b/spec-jasmine/postgres/associations.has-many.spec.js
-var config    = require("../config/config")
-  , Sequelize = require("../../index")
-  , sequelize = new Sequelize(config.postgres.database, config.postgres.username, config.postgres.password, {
-      logging: false,
-      port: config.postgres.port,
-      dialect: 'postgres'
-    })
-  , Helpers   = new (require("../config/helpers"))(sequelize)
-describe('HasMany', function() {
-  beforeEach(function() { Helpers.sync() })
-  afterEach(function() { Helpers.drop() })
-  //prevent periods from occurring in the table name since they are used to delimit (table.column)
-  var User  = sequelize.define('User' + Math.ceil(Math.random()*10000000), { name: Sequelize.STRING })
-    , Task  = sequelize.define('Task' + Math.ceil(Math.random()*10000000), { name: Sequelize.STRING })
-    , users = null
-    , tasks = null
-  User.hasMany(Task, {as:'Tasks'})
-  Task.hasMany(User, {as:'Users'})
-  beforeEach(function() {
-    Helpers.async(function(_done) {
-      Helpers.Factories.DAO(User.name, {name: 'User' + Math.random()}, function(_users) {
-        users = _users; _done()
-      }, 5)
-    })
-    Helpers.async(function(_done) {
-      Helpers.Factories.DAO(Task.name, {name: 'Task' + Math.random()}, function(_tasks) {
-        tasks = _tasks; _done()
-      }, 2)
-    })
-  })
-  describe('addDAO / getDAO', function() {
-    var user = null
-      , task = null
-    beforeEach(function() {
-      Helpers.async(function(done) {
-        User.all().on('success', function(_users) {
-          Task.all().on('success', function(_tasks) {
-            user = _users[0]
-            task = _tasks[0]
-            done()
-          })
-        })
-      })
-    })
-    it('should correctly add an association to the dao', function() {
-      Helpers.async(function(done) {
-        user.getTasks().on('success', function(_tasks) {
-          expect(_tasks.length).toEqual(0)
-          user.addTask(task).on('success', function() {
-            user.getTasks().on('success', function(_tasks) {
-              expect(_tasks.length).toEqual(1)
-              done()
-            })
-          })
-        })
-      })
-    })
-  })
-  describe('removeDAO', function() {
-    var user  = null
-      , tasks = null
-    beforeEach(function() {
-      Helpers.async(function(done) {
-        User.all().on('success', function(users) {
-          Task.all().on('success', function(_tasks) {
-            user = users[0]
-            tasks = _tasks
-            done()
-          })
-        })
-      })
-    })
-    it("should correctly remove associated objects", function() {
-      Helpers.async(function(done) {
-        user.getTasks().on('success', function(__tasks) {
-          expect(__tasks.length).toEqual(0)
-          user.setTasks(tasks).on('success', function() {
-            user.getTasks().on('success', function(_tasks) {
-              expect(_tasks.length).toEqual(tasks.length)
-              user.removeTask(tasks[0]).on('success', function() {
-                user.getTasks().on('success', function(_tasks) {
-                  expect(_tasks.length).toEqual(tasks.length - 1)
-                  done()
-                })
-              })
-            })
-          })
-        })
-      })
-    })
-  })
-})
--- a/spec-jasmine/postgres/associations.spec.js
+++ b/spec-jasmine/postgres/associations.spec.js
-var config    = require("../config/config")
-  , Sequelize = require("../../index")
-  , sequelize = new Sequelize(config.postgres.database, config.postgres.username, config.postgres.password, {
-      logging: false,
-      port: config.postgres.port,
-      dialect: 'postgres'
-    })
-  , Helpers   = new (require("../config/helpers"))(sequelize)
-describe('Associations', function() {
-  beforeEach(function() { Helpers.sync() })
-  afterEach(function() { Helpers.drop() })
-  /////////// many-to-many with same prefix ////////////
-  describe('many-to-many', function() {
-    describe('where tables have the same prefix', function() {
-      var Table2 = sequelize.define('wp_table2', {foo: Sequelize.STRING})
-        , Table1 = sequelize.define('wp_table1', {foo: Sequelize.STRING})
-      Table1.hasMany(Table2)
-      Table2.hasMany(Table1)
-      it("should create a table wp_table1wp_table2s", function() {
-        Helpers.async(function(done) {
-          expect(sequelize.daoFactoryManager.getDAO('wp_table1swp_table2s')).toBeDefined()
-          done()
-        })
-      })
-    })
-    describe('when join table name is specified', function() {
-      var Table2 = sequelize.define('ms_table1', {foo: Sequelize.STRING})
-        , Table1 = sequelize.define('ms_table2', {foo: Sequelize.STRING})
-      Table1.hasMany(Table2, {joinTableName: 'table1_to_table2'})
-      Table2.hasMany(Table1, {joinTableName: 'table1_to_table2'})
-      it("should not use a combined name", function() {
-        expect(sequelize.daoFactoryManager.getDAO('ms_table1sms_table2s')).toBeUndefined()
-      })
-      it("should use the specified name", function() {
-        expect(sequelize.daoFactoryManager.getDAO('table1_to_table2')).toBeDefined()
-      })
-    })
-  })
-})
--- a/spec-jasmine/sequelize.spec.js
+++ b/spec-jasmine/sequelize.spec.js
-var config         = require("./config/config")
-  , Sequelize      = require("../index")
-  , QueryInterface = require("../lib/query-interface")
-describe('Sequelize', function() {
-  var sequelize = null
-    , Helpers   = null
-  var setup = function(options) {
-    options   = options || {}
-    if (!options.hasOwnProperty('pool'))
-      options.pool = config.mysql.pool
-    if (!options.hasOwnProperty('logging'))
-      options.logging = false
-    if (!options.hasOwnProperty('host'))
-      options.host = config.mysql.host
-    if (!options.hasOwnProperty('port'))
-      options.port = config.mysql.port
-    sequelize = new Sequelize(config.mysql.database, config.mysql.username, config.mysql.password, options)
-    Helpers   = new (require("./config/helpers"))(sequelize)
-    return options
-  }
-  beforeEach(function() { setup() })
-  afterEach(function() { sequelize = null })
-  describe('constructor', function() {
-    it('should pass the global options correctly', function() {
-      setup({ logging: false, define: { underscored:true } })
-      var DAO = sequelize.define('dao', {name: Sequelize.STRING})
-      expect(DAO.options.underscored).toBeTruthy()
-    })
-    it('should correctly set the host and the port', function() {
-      var options = setup({ host: '127.0.0.1', port: 1234 })
-      expect(sequelize.config.host).toEqual(options.host)
-      expect(sequelize.config.port).toEqual(options.port)
-    })
-  })
-  describe('define', function() {
-    it("adds a new dao to the dao manager", function() {
-      expect(sequelize.daoFactoryManager.all.length).toEqual(0)
-      sequelize.define('foo', { title: Sequelize.STRING })
-      expect(sequelize.daoFactoryManager.all.length).toEqual(1)
-    })
-    it("overwrites global options", function() {
-      setup({ define: { collate: 'utf8_general_ci' } })
-      var DAO = sequelize.define('foo', {bar: Sequelize.STRING}, {collate: 'utf8_bin'})
-      expect(DAO.options.collate).toEqual('utf8_bin')
-    })
-    it("inherits global collate option", function() {
-      setup({ define: { collate: 'utf8_general_ci' } })
-      var DAO = sequelize.define('foo', {bar: Sequelize.STRING})
-      expect(DAO.options.collate).toEqual('utf8_general_ci')
-    })
-    it("inherits global classMethods and instanceMethods", function() {
-      setup({
-        define: {
-          classMethods : { globalClassMethod : function() {} },
-          instanceMethods : { globalInstanceMethod : function() {} }
-        }
-      })
-      var DAO = sequelize.define('foo', {bar: Sequelize.STRING}, {
-        classMethods : { localClassMethod : function() {} }
-      })
-      expect(typeof DAO.options.classMethods.globalClassMethod).toEqual('function')
-      expect(typeof DAO.options.classMethods.localClassMethod).toEqual('function')
-      expect(typeof DAO.options.instanceMethods.globalInstanceMethod).toEqual('function')
-    })
-    it("uses the passed tableName", function(done) {
-      var Photo = sequelize.define('Foto', { name: Sequelize.STRING }, { tableName: 'photos' })
-      Photo.sync({ force: true }).success(function() {
-        sequelize.getQueryInterface().showAllTables().success(function(tableNames) {
-          expect(tableNames).toContain('photos')
-          done()
-        })
-      })
-    })
-  })
-  describe('sync', function() {
-    it("synchronizes all daos", function() {
-      var Project = sequelize.define('project' + config.rand(), { title: Sequelize.STRING })
-      var Task = sequelize.define('task' + config.rand(), { title: Sequelize.STRING })
-      Helpers.async(function(done) {
-        sequelize.sync().success(function() {
-          Project.create({title: 'bla'}).success(function() {
-            Task.create({title: 'bla'}).success(done)
-          })
-        })
-      })
-    })
-  })
-  describe('import', function() {
-    it("imports a dao definition from a file", function() {
-      var Project = sequelize.import(__dirname + "/assets/project")
-      expect(Project).toBeDefined()
-    })
-  })
-})
--- a/spec-jasmine/sqlite/dao-factory.spec.js
+++ b/spec-jasmine/sqlite/dao-factory.spec.js
-var config    = require("../config/config")
-  , Sequelize = require("../../index")
-  , dbFile    = __dirname + '/test.sqlite'
-  , storages  = [':memory:', dbFile]
-describe('DAOFactory', function() {
-  storages.forEach(function(storage) {
-    describe('with storage "' + storage + '"', function() {
-      var User      = null
-        , sequelize = null
-        , Helpers   = null
-      beforeEach(function() {
-        sequelize = new Sequelize(config.database, config.username, config.password, {
-          logging: false,
-          dialect: 'sqlite',
-          storage: storage
-        })
-        Helpers = new (require("../config/helpers"))(sequelize)
-        User = sequelize.define('User', {
-          age: Sequelize.INTEGER,
-          name: Sequelize.STRING,
-          bio: Sequelize.TEXT
-        })
-        Helpers.sync()
-      })
-      afterEach(function() {
-        Helpers.dropAllTables()
-        if(storage == dbFile) {
-          Helpers.async(function(done) {
-            require("fs").unlink(__dirname + '/test.sqlite', done)
-          })
-        }
-      })
-      describe('create', function() {
-        it('creates a table entry', function() {
-          Helpers.async(function(done) {
-            User
-              .create({ age: 21, name: 'John Wayne', bio: 'noot noot' })
-              .success(done)
-              .error(function(err) { console.log(err) })
-          })
-          Helpers.async(function(done) {
-            User.all().success(function(users) {
-              var usernames = users.map(function(user) {
-                return user.name
-              })
-              expect(usernames).toEqual(['John Wayne'])
-              done()
-            }).error(function(err){ console.log(err) })
-          })
-        })
-        it('should allow the creation of an object with options as attribute', function() {
-          var Person = sequelize.define('Person', {
-            name: Sequelize.STRING,
-            options: Sequelize.TEXT
-          })
-          Helpers.async(function(done) {
-            Person.sync({force: true}).success(done)
-          })
-          Helpers.async(function(done) {
-            var options = JSON.stringify({ foo: 'bar', bar: 'foo' })
-            Helpers.Factories.DAO('Person', {
-              name: 'John Doe',
-              options: options
-            }, function(people) {
-              expect(people[0].options).toEqual(options)
-              done()
-            })
-          })
-        })
-        it('should allow the creation of an object with a boolean (true) as attribute', function() {
-          var Person = sequelize.define('Person', {
-            name: Sequelize.STRING,
-            has_swag: Sequelize.BOOLEAN
-          })
-          Helpers.async(function(done) {
-            Person.sync({force: true}).success(done)
-          })
-          Helpers.async(function(done) {
-            Helpers.Factories.DAO('Person', {
-              name: 'John Doe',
-              has_swag: true
-            }, function(people) {
-              expect(people[0].has_swag).toBeTruthy();
-              done()
-            })
-          })
-        })
-        it('should allow the creation of an object with a boolean (false) as attribute', function() {
-          var Person = sequelize.define('Person', {
-            name: Sequelize.STRING,
-            has_swag: Sequelize.BOOLEAN
-          })
-          Helpers.async(function(done) {
-            Person.sync({force: true}).success(done)
-          })
-          Helpers.async(function(done) {
-            Helpers.Factories.DAO('Person', {
-              name: 'John Doe',
-              has_swag: false
-            }, function(people) {
-              expect(people[0].has_swag).toBeFalsy();
-              done()
-            })
-          })
-        })
-      })
-      ////////// find //////////////
-      describe('.find', function() {
-        beforeEach(function() {
-          Helpers.Factories.User({name: 'user', bio: 'foobar'}, null, 2)
-        })
-        it("finds normal lookups", function() {
-          Helpers.async(function(done) {
-            User.find({ where: { name:'user' } }).success(function(user) {
-              expect(user.name).toEqual('user')
-              done()
-            })
-          })
-        })
-        it("should make aliased attributes available", function() {
-          Helpers.async(function(done) {
-            User.find({ where: { name:'user' }, attributes: ['id', ['name', 'username']] }).success(function(user) {
-              expect(user.username).toEqual('user')
-              done()
-            })
-          })
-        })
-      })
-      ////////// all //////////////
-      describe('.all', function() {
-        beforeEach(function() {
-          Helpers.Factories.User({name: 'user', bio: 'foobar'}, null, 2)
-        })
-        it("should return all users", function() {
-          Helpers.async(function(done) {
-            User.all().on('success', function(users) {
-              done()
-              expect(users.length).toEqual(2)
-            }).on('error', function(err) { console.log(err) })
-          })
-        })
-      })
-      ////////// min //////////////
-      describe('.min', function() {
-        it("should return the min value", function() {
-          for(var i = 2; i < 5; i++) Helpers.Factories.User({ age: i })
-          Helpers.async(function(done) {
-            User.min('age').on('success', function(min) {
-              expect(min).toEqual(2); done()
-            })
-          })
-        })
-      })
-      ////////// max //////////////
-      describe('.max', function() {
-        it("should return the max value", function() {
-          for(var i = 2; i <= 5; i++) Helpers.Factories.User({ age: i })
-          Helpers.async(function(done) {
-            User.max('age').on('success', function(min) {
-              expect(min).toEqual(5); done()
-            })
-          })
-        })
-      })
-    })
-  })
-})
--- a/spec-jasmine/sqlite/dao.spec.js
+++ b/spec-jasmine/sqlite/dao.spec.js
-// var config    = require("./config/config")
-//   , Sequelize = require("../index")
-//   , User      = null
-//   , sequelize = new Sequelize(config.database, config.username, config.password, {
-//       logging: false,
-//       dialect: dialect
-//     })
-//   , Helpers   = new (require("./config/helpers"))(sequelize)
-// describe('DAO', function() {
-//   var setup = function() {
-//     Helpers.async(function(done) {
-//       User = sequelize.define('User', { username: Sequelize.STRING })
-//       User.sync({ force: true }).success(done)
-//     })
-//   }
-//   beforeEach(function() { Helpers.dropAllTables(); setup() })
-//   afterEach(function() { Helpers.dropAllTables() })
-//   describe('findAll', function() {
-//     it("can handle dates correctly", function() {
-//     })
-//   })
-// })
--- a/spec-jasmine/utils.spec.js
+++ b/spec-jasmine/utils.spec.js
-var Utils = require('../lib/utils')
-describe('Utils', function() {
-  describe('removeCommentsFromFunctionString', function() {
-    it("removes line comments at the start of a line", function() {
-      var functionWithLineComments = function() {
-        // noot noot
-      }
-      var result = Utils.removeCommentsFromFunctionString(functionWithLineComments.toString())
-      expect(result).toNotMatch(/.*noot.*/)
-    })
-    it("removes lines comments in the middle of a line", function() {
-      var functionWithLineComments = function() {
-        alert(1) // noot noot
-      }
-      var result = Utils.removeCommentsFromFunctionString(functionWithLineComments.toString())
-      expect(result).toNotMatch(/.*noot.*/)
-    })
-    it("removes range comments", function() {
-      var s = function() {
-        alert(1) /*
-          noot noot
-        */
-        alert(2) /*
-          foo
-        */
-      }.toString()
-      var result = Utils.removeCommentsFromFunctionString(s)
-      expect(result).toNotMatch(/.*noot.*/)
-      expect(result).toNotMatch(/.*foo.*/)
-      expect(result).toMatch(/.*alert\(2\).*/)
-    })
-  })
-  describe('argsArePrimaryKeys', function() {
-    it("doesn't detect primary keys if primareyKeys and values have different lengths", function() {
-      expect(Utils.argsArePrimaryKeys([1,2,3], [1])).toBeFalsy()
-    })
-    it("doesn't detect primary keys if primary keys are hashes or arrays", function() {
-      expect(Utils.argsArePrimaryKeys([[]], [1])).toBeFalsy()
-    })
-    it('detects primary keys if length is correct and data types are matching', function() {
-      expect(Utils.argsArePrimaryKeys([1,2,3], ["INTEGER", "INTEGER", "INTEGER"])).toBeTruthy()
-    })
-    it("detects primary keys if primary keys are dates and lengths are matching", function() {
-      expect(Utils.argsArePrimaryKeys([new Date()], ['foo'])).toBeTruthy()
-    })
-  })
-  describe('underscore', function() {
-    describe('underscoredIf', function() {
-      it('is defined', function() {
-        expect(Utils._.underscoredIf).toBeDefined()
-      })
-      it('underscores if second param is true', function() {
-        expect(Utils._.underscoredIf('fooBar', true)).toEqual('foo_bar')
-      })
-      it("doesn't underscore if second param is false", function() {
-        expect(Utils._.underscoredIf('fooBar', false)).toEqual('fooBar')
-      })
-    })
-    describe('camelizeIf', function() {
-      it('is defined', function() {
-        expect(Utils._.camelizeIf).toBeDefined()
-      })
-      it('camelizes if second param is true', function() {
-        expect(Utils._.camelizeIf('foo_bar', true)).toEqual('fooBar')
-      })
-      it("doesn't camelize if second param is false", function() {
-        expect(Utils._.underscoredIf('fooBar', true)).toEqual('foo_bar')
-      })
-    })
-  })
-  describe('isHash', function() {
-    it('doesn\'t match arrays', function() {
-      expect(Utils.isHash([])).toBeFalsy();
-    });
-    it('doesn\'t match null', function() {
-      expect(Utils.isHash(null)).toBeFalsy();
-    });
-    it('matches plain objects', function() {
-    	var values = {
-    	  'name': {
-    	    'first': 'Foo',
-    	    'last': 'Bar'
-    	  }
-    	};
-      expect(Utils.isHash(values)).toBeTruthy();
-    });
-    it('matches plain objects with length property/key', function() {
-      var values = {
-    	  'name': {
-    	    'first': 'Foo',
-    	    'last': 'Bar'
-    	  },
-    	  'length': 1
-    	};
-    	expect(Utils.isHash(values)).toBeTruthy();
-    });
-  });
-  describe('format', function() {
-    it('should format where clause correctly when the value is truthy', function() {
-      var where = ['foo = ?', 1];
-      expect(Utils.format(where)).toEqual('foo = 1');
-    });
-    it('should format where clause correctly when the value is falsy', function() {
-      var where = ['foo = ?', 0];
-      expect(Utils.format(where)).toEqual('foo = 0');
-    });
-  });
-})
--- a/spec/assets/project.js
+++ b/spec/assets/project.js
-module.exports = function(sequelize, DataTypes) {
-  return sequelize.define('Project' + parseInt(Math.random() * 9999999999999999), {
-     name: DataTypes.STRING
-   })
-}
\ No newline at end of file
--- a/spec/associations/belongs-to.spec.js
+++ b/spec/associations/belongs-to.spec.js
-if (typeof require === 'function') {
-  const buster    = require("buster")
-      , Helpers   = require('../buster-helpers')
-      , Sequelize = require('../../index')
-      , dialect   = Helpers.getTestDialect()
-}
-buster.spec.expose()
-buster.testRunner.timeout = 500
-describe(Helpers.getTestDialectTeaser("BelongsTo"), function() {
-  before(function(done) {
-    Helpers.initTests({
-      dialect: dialect,
-      beforeComplete: function(sequelize) {
-        this.sequelize = sequelize
-      }.bind(this),
-      onComplete: done
-    })
-  })
-  describe('setAssociation', function() {
-    it('clears the association if null is passed', function(done) {
-      var User = this.sequelize.define('UserXYZ', { username: Sequelize.STRING })
-        , Task = this.sequelize.define('TaskXYZ', { title: Sequelize.STRING })
-      Task.belongsTo(User)
-      this.sequelize.sync({ force: true }).success(function() {
-        User.create({ username: 'foo' }).success(function(user) {
-          Task.create({ title: 'task' }).success(function(task) {
-            task.setUserXYZ(user).success(function() {
-              task.getUserXYZ().success(function(user) {
-                expect(user).not.toEqual(null)
-                task.setUserXYZ(null).success(function() {
-                  task.getUserXYZ().success(function(user) {
-                    expect(user).toEqual(null)
-                    done()
-                  })
-                })
-              })
-            })
-          })
-        })
-      })
-    })
-  })
-  describe("Foreign key constraints", function() {
-    it("are not enabled by default", function(done) {
-      var Task = this.sequelize.define('Task', { title: Sequelize.STRING })
-        , User = this.sequelize.define('User', { username: Sequelize.STRING })
-      Task.belongsTo(User)
-      this.sequelize.sync({ force: true }).success(function() {
-        User.create({ username: 'foo' }).success(function(user) {
-          Task.create({ title: 'task' }).success(function(task) {
-            task.setUser(user).success(function() {
-              user.destroy().success(function() {
-                Task.findAll().success(function(tasks) {
-                  expect(tasks.length).toEqual(1)
-                  done()
-                })
-              })
-            })
-          })
-        })
-      })
-    })
-    it("can cascade deletes", function(done) {
-      var Task = this.sequelize.define('Task', { title: Sequelize.STRING })
-        , User = this.sequelize.define('User', { username: Sequelize.STRING })
-      Task.belongsTo(User, {onDelete: 'cascade'})
-      this.sequelize.sync({ force: true }).success(function() {
-        User.create({ username: 'foo' }).success(function(user) {
-          Task.create({ title: 'task' }).success(function(task) {
-            task.setUser(user).success(function() {
-              user.destroy().success(function() {
-                Task.findAll().success(function(tasks) {
-                  expect(tasks.length).toEqual(0)
-                  done()
-                })
-              })
-            })
-          })
-        })
-      })
-    })
-    it("can restrict deletes", function(done) {
-      var Task = this.sequelize.define('Task', { title: Sequelize.STRING })
-        , User = this.sequelize.define('User', { username: Sequelize.STRING })
-      Task.belongsTo(User, {onDelete: 'restrict'})
-      this.sequelize.sync({ force: true }).success(function() {
-        User.create({ username: 'foo' }).success(function(user) {
-          Task.create({ title: 'task' }).success(function(task) {
-            task.setUser(user).success(function() {
-              user.destroy().error(function() {
-                // Should fail due to FK restriction
-                Task.findAll().success(function(tasks) {
-                  expect(tasks.length).toEqual(1)
-                  done()
-                })
-              })
-            })
-          })
-        })
-      })
-    })
-    it("can cascade updates", function(done) {
-      var Task = this.sequelize.define('Task', { title: Sequelize.STRING })
-        , User = this.sequelize.define('User', { username: Sequelize.STRING })
-      Task.belongsTo(User, {onUpdate: 'cascade'})
-      this.sequelize.sync({ force: true }).success(function() {
-        User.create({ username: 'foo' }).success(function(user) {
-          Task.create({ title: 'task' }).success(function(task) {
-            task.setUser(user).success(function() {
-              // Changing the id of a DAO requires a little dance since
-              // the `UPDATE` query generated by `save()` uses `id` in the
-              // `WHERE` clause
-              var tableName = user.QueryInterface.QueryGenerator.addSchema(user.__factory)
-              user.QueryInterface.update(user, tableName, {id: 999}, user.id)
-              .success(function() {
-                Task.findAll().success(function(tasks) {
-                  expect(tasks.length).toEqual(1)
-                  expect(tasks[0].UserId).toEqual(999)
-                  done()
-                })
-              })
-            })
-          })
-        })
-      })
-    })
-    it("can restrict updates", function(done) {
-      var Task = this.sequelize.define('Task', { title: Sequelize.STRING })
-        , User = this.sequelize.define('User', { username: Sequelize.STRING })
-      Task.belongsTo(User, {onUpdate: 'restrict'})
-      this.sequelize.sync({ force: true }).success(function() {
-        User.create({ username: 'foo' }).success(function(user) {
-          Task.create({ title: 'task' }).success(function(task) {
-            task.setUser(user).success(function() {
-              // Changing the id of a DAO requires a little dance since
-              // the `UPDATE` query generated by `save()` uses `id` in the
-              // `WHERE` clause
-              var tableName = user.QueryInterface.QueryGenerator.addSchema(user.__factory)
-              user.QueryInterface.update(user, tableName, {id: 999}, user.id)
-              .error(function() {
-                // Should fail due to FK restriction
-                Task.findAll().success(function(tasks) {
-                  expect(tasks.length).toEqual(1)
-                  done()
-                })
-              })
-            })
-          })
-        })
-      })
-    })
-  })
-  describe("Association options", function() {
-    it('can specify data type for autogenerated relational keys', function(done) {
-      var User = this.sequelize.define('UserXYZ', { username: Sequelize.STRING })
-        , dataTypes = [Sequelize.INTEGER, Sequelize.BIGINT, Sequelize.STRING]
-        , self = this
-      dataTypes.forEach(function(dataType) {
-        var tableName = 'TaskXYZ_' + dataType.toString()
-          , Task = self.sequelize.define(tableName, { title: Sequelize.STRING })
-        Task.belongsTo(User, { foreignKey: 'userId', keyType: dataType })
-        self.sequelize.sync({ force: true }).success(function() {
-          expect(Task.rawAttributes.userId.type.toString())
-            .toEqual(dataType.toString())
-          dataTypes.splice(dataTypes.indexOf(dataType), 1)
-          if (!dataTypes.length) {
-            done()
-          }
-        })
-      })
-    })
-  })
-})
--- a/spec/associations/has-many.spec.js
+++ b/spec/associations/has-many.spec.js
--- a/spec/associations/has-one.spec.js
+++ b/spec/associations/has-one.spec.js
-if (typeof require === 'function') {
-  const buster    = require("buster")
-      , Sequelize = require("../../index")
-      , Helpers   = require('../buster-helpers')
-      , dialect   = Helpers.getTestDialect()
-}
-buster.spec.expose()
-buster.testRunner.timeout = 1500
-describe(Helpers.getTestDialectTeaser("HasOne"), function() {
-  before(function(done) {
-    var self = this
-    Helpers.initTests({
-      dialect: dialect,
-      beforeComplete: function(sequelize) { self.sequelize = sequelize },
-      onComplete: done
-    })
-  })
-  describe('setAssociation', function() {
-    it('//clears the association if null is passed', function(done) {
-      var User = this.sequelize.define('UserXYZ', { username: Sequelize.STRING })
-        , Task = this.sequelize.define('TaskXYZ', { title: Sequelize.STRING })
-      User.hasOne(Task)
-      this.sequelize.sync({ force: true }).success(function() {
-        User.create({ username: 'foo' }).success(function(user) {
-          Task.create({ title: 'task' }).success(function(task) {
-            user.setTaskXYZ(task).success(function() {
-              user.getTaskXYZ().success(function(task) {
-                expect(task).not.toEqual(null)
-                user.setTaskXYZ(null).success(function() {
-                  user.getTaskXYZ().success(function(task) {
-                    expect(task).toEqual(null)
-                    done()
-                  })
-                })
-              })
-            })
-          })
-        })
-      })
-    })
-  })
-  describe("Foreign key constraints", function() {
-    it("are not enabled by default", function(done) {
-      var Task = this.sequelize.define('Task', { title: Sequelize.STRING })
-        , User = this.sequelize.define('User', { username: Sequelize.STRING })
-      User.hasOne(Task)
-      this.sequelize.sync({ force: true }).success(function() {
-        User.create({ username: 'foo' }).success(function(user) {
-          Task.create({ title: 'task' }).success(function(task) {
-            user.setTask(task).success(function() {
-              user.destroy().success(function() {
-                Task.findAll().success(function(tasks) {
-                  expect(tasks.length).toEqual(1)
-                  done()
-                })
-              })
-            })
-          })
-        })
-      })
-    })
-    it("can cascade deletes", function(done) {
-      var Task = this.sequelize.define('Task', { title: Sequelize.STRING })
-        , User = this.sequelize.define('User', { username: Sequelize.STRING })
-      User.hasOne(Task, {onDelete: 'cascade'})
-      this.sequelize.sync({ force: true }).success(function() {
-        User.create({ username: 'foo' }).success(function(user) {
-          Task.create({ title: 'task' }).success(function(task) {
-            user.setTask(task).success(function() {
-              user.destroy().success(function() {
-                Task.findAll().success(function(tasks) {
-                  expect(tasks.length).toEqual(0)
-                  done()
-                })
-              })
-            })
-          })
-        })
-      })
-    })
-    it("can restrict deletes", function(done) {
-      var Task = this.sequelize.define('Task', { title: Sequelize.STRING })
-        , User = this.sequelize.define('User', { username: Sequelize.STRING })
-      User.hasOne(Task, {onDelete: 'restrict'})
-      this.sequelize.sync({ force: true }).success(function() {
-        User.create({ username: 'foo' }).success(function(user) {
-          Task.create({ title: 'task' }).success(function(task) {
-            user.setTask(task).success(function() {
-              user.destroy().error(function() {
-                // Should fail due to FK restriction
-                Task.findAll().success(function(tasks) {
-                  expect(tasks.length).toEqual(1)
-                  done()
-                })
-              })
-            })
-          })
-        })
-      })
-    })
-    it("can cascade updates", function(done) {
-      var Task = this.sequelize.define('Task', { title: Sequelize.STRING })
-        , User = this.sequelize.define('User', { username: Sequelize.STRING })
-      User.hasOne(Task, {onUpdate: 'cascade'})
-      this.sequelize.sync({ force: true }).success(function() {
-        User.create({ username: 'foo' }).success(function(user) {
-          Task.create({ title: 'task' }).success(function(task) {
-            user.setTask(task).success(function() {
-              // Changing the id of a DAO requires a little dance since
-              // the `UPDATE` query generated by `save()` uses `id` in the
-              // `WHERE` clause
-              var tableName = user.QueryInterface.QueryGenerator.addSchema(user.__factory)
-              user.QueryInterface.update(user, tableName, {id: 999}, user.id)
-              .success(function() {
-                Task.findAll().success(function(tasks) {
-                  expect(tasks.length).toEqual(1)
-                  expect(tasks[0].UserId).toEqual(999)
-                  done()
-                })
-              })
-            })
-          })
-        })
-      })
-    })
-    it("can restrict updates", function(done) {
-      var Task = this.sequelize.define('Task', { title: Sequelize.STRING })
-        , User = this.sequelize.define('User', { username: Sequelize.STRING })
-      User.hasOne(Task, {onUpdate: 'restrict'})
-      this.sequelize.sync({ force: true }).success(function() {
-        User.create({ username: 'foo' }).success(function(user) {
-          Task.create({ title: 'task' }).success(function(task) {
-            user.setTask(task).success(function() {
-              // Changing the id of a DAO requires a little dance since
-              // the `UPDATE` query generated by `save()` uses `id` in the
-              // `WHERE` clause
-              var tableName = user.QueryInterface.QueryGenerator.addSchema(user.__factory)
-              user.QueryInterface.update(user, tableName, {id: 999}, user.id)
-              .error(function() {
-                // Should fail due to FK restriction
-                Task.findAll().success(function(tasks) {
-                  expect(tasks.length).toEqual(1)
-                  done()
-                })
-              })
-            })
-          })
-        })
-      })
-    })
-  })
-  describe("Association options", function() {
-    it('can specify data type for autogenerated relational keys', function(done) {
-      var User = this.sequelize.define('UserXYZ', { username: Sequelize.STRING })
-        , dataTypes = [Sequelize.INTEGER, Sequelize.BIGINT, Sequelize.STRING]
-        , self = this
-      dataTypes.forEach(function(dataType) {
-        var tableName = 'TaskXYZ_' + dataType.toString()
-          , Task = self.sequelize.define(tableName, { title: Sequelize.STRING })
-        User.hasOne(Task, { foreignKey: 'userId', keyType: dataType })
-        self.sequelize.sync({ force: true }).success(function() {
-          expect(Task.rawAttributes.userId.type.toString())
-            .toEqual(dataType.toString())
-          dataTypes.splice(dataTypes.indexOf(dataType), 1)
-          if (!dataTypes.length) {
-            done()
-          }
-        })
-      })
-    })
-  })
-})
--- a/spec/associations/mixin.spec.js
+++ b/spec/associations/mixin.spec.js
-if (typeof require === 'function') {
-  const buster    = require("buster")
-      , Helpers   = require('../buster-helpers')
-      , Sequelize = require('../../index')
-      , dialect   = Helpers.getTestDialect()
-}
-buster.spec.expose()
-describe(Helpers.getTestDialectTeaser("Mixin"), function() {
-  before(function(done) {
-    Helpers.initTests({
-      dialect: dialect,
-      beforeComplete: function(sequelize) {
-        this.sequelize = sequelize
-      }.bind(this),
-      onComplete: done
-    })
-  })
-  describe('getAssociation', function() {
-    it('returns the respective part of the association for 1:1 associations', function() {
-      var User = this.sequelize.define('User', {})
-      var Task = this.sequelize.define('Task', {})
-      User.hasOne(Task)
-      Task.belongsTo(User)
-      expect(User.getAssociation(Task).target).toEqual(Task)
-    })
-  })
-})
--- a/spec/buster.js
+++ b/spec/buster.js
-var config = module.exports
-config["node tests"] = {
-  environment: "node",
-  rootPath: "../",
-  tests: [
-    "spec/**/*.spec.js"
-  ]
-}
--- a/spec/config/factories.js
+++ b/spec/config/factories.js
-var Factories = module.exports = function(helpers) {
-  this.helpers = helpers
-  this.sequelize = this.helpers.sequelize
-}
-Factories.prototype.DAO = function(daoName, options, callback, count) {
-  count = count || 1
-  var self   = this
-    , daos = []
-  this.helpers.async(function(done) {
-    var DAO  = self.sequelize.daoFactoryManager.getDAO(daoName)
-    var create = function(cb) {
-      DAO.create(options).on('success', function(dao) {
-        daos.push(dao)
-        cb && cb()
-      }).on('error', function(err) {
-        console.log(err)
-        done()
-      })
-    }
-    var cb = function() {
-      if(--count) {
-        create(cb)
-      } else {
-        done()
-        callback && callback(daos)
-      }
-    }
-    create(cb)
-  })
-}
-Factories.prototype.User = function(options, callback, count) {
-  this.DAO('User', options, callback, count)
-}
--- a/spec/config/helpers.js
+++ b/spec/config/helpers.js
-Sequelize = require("../../index")
-var Helpers = module.exports = function(sequelize) {
-  this.sequelize = sequelize
-  this.Factories = new (require("./factories"))(this)
-}
-Helpers.prototype.sync = function() {
-  var self = this
-  this.async(function(done) {
-    self.sequelize
-      .sync({force: true})
-      .success(done)
-      .failure(function(err) { console.log(err) })
-  })
-}
-Helpers.prototype.drop = function() {
-  var self = this
-  this.async(function(done) {
-    self.sequelize
-      .drop()
-      .on('success', done)
-      .on('error', function(err) { console.log(err) })
-  })
-}
-Helpers.prototype.dropAllTables = function() {
-  var self = this
-  this.async(function(done) {
-    self.sequelize
-      .getQueryInterface()
-      .dropAllTables()
-      .success(done)
-      .error(function(err) { console.log(err) })
-  })
-}
-Helpers.prototype.async = function(fct) {
-  var done = false
-  runs(function() {
-    fct(function() { return done = true })
-  })
-  waitsFor(function(){ return done })
-}
--- a/spec/configuration.spec.js
+++ b/spec/configuration.spec.js
-if(typeof require === 'function') {
-  const buster           = require("buster")
-    , CustomEventEmitter = require("../lib/emitters/custom-event-emitter")
-    , Helpers            = require('./buster-helpers')
-    , config             = require(__dirname + "/config/config")
-    , dialect            = Helpers.getTestDialect()
-}
-buster.spec.expose()
-buster.testRunner.timeout = 1000
-var Sequelize = require(__dirname + '/../index')
-describe(Helpers.getTestDialectTeaser("Configuration"), function() {
-  describe('Connections problems should fail with a nice message', function() {
-    it('should give us an error for not having the correct server details', function(done) {
-      var domain
-      try {
-        domain = require('domain')
-      } catch (err) {
-        console.log('WARNING: Configuration specs requires Node version >= 0.8')
-        expect('').toEqual('') // Silence Buster!
-        done()
-      }
-      var d = domain.create()
-      var sequelize = new Sequelize(config[dialect].database, config[dialect].username, config[dialect].password, {storage: '/path/to/no/where/land', logging: false, host: '0.0.0.1', port: config[dialect].port, dialect: dialect})
-      d.add(sequelize.query)
-      d.on('error', function(err){
-        d.remove(sequelize.query)
-        var msg = 'Failed to find SQL server. Please double check your settings.'
-        if (dialect === "postgres" || dialect === "postgres-native") {
-          msg = 'Failed to find PostgresSQL server. Please double check your settings.'
-        }
-        else if (dialect === "mysql") {
-          msg = 'Failed to find MySQL server. Please double check your settings.'
-        }
-        expect(err.message).toEqual(msg)
-        done()
-      })
-      d.run(function(){
-        sequelize.query('select 1 as hello')
-        .success(function(){})
-      })
-    })
-    it('should give us an error for not having the correct login information', function(done) {
-      if (dialect !== "postgres" && dialect !== "postgres-native" && dialect !== "mysql") {
-        // This dialect doesn't support incorrect login information
-        expect('').toEqual('') // Silence Buster
-        return done()
-      }
-      var domain
-      try {
-        domain = require('domain')
-      } catch (err) {
-        console.log('WARNING: Configuration specs requires Node version >= 0.8')
-        expect('').toEqual('') // Silence Buster!
-        done()
-      }
-      var d = domain.create()
-      var sequelize = new Sequelize(config[dialect].database, config[dialect].username, 'fakepass123', {logging: false, host: config[dialect].host, port: 1, dialect: dialect})
-      d.add(sequelize.query)
-      d.on('error', function(err){
-        d.remove(sequelize.query)
-        var msg = 'Failed to authenticate for SQL. Please double check your settings.'
-        if (dialect === "postgres" || dialect === "postgres-native") {
-          msg = 'Failed to authenticate for PostgresSQL. Please double check your settings.'
-        }
-        else if (dialect === "mysql") {
-          msg = 'Failed to authenticate for MySQL. Please double check your settings.'
-        }
-        expect(err.message).toEqual(msg)
-        done()
-      })
-      d.run(function(){
-        sequelize.query('select 1 as hello')
-        .success(function(){})
-      })
-    })
-  })
-  describe('Instantiation with a URL string', function() {
-    it('should accept username, password, host, port, and database', function() {
-      var sequelize = new Sequelize('mysql://user:pass@example.com:9821/dbname')
-      var config = sequelize.config
-      var options = sequelize.options
-      expect(options.dialect).toEqual('mysql')
-      expect(config.database).toEqual('dbname')
-      expect(config.host).toEqual('example.com')
-      expect(config.username).toEqual('user')
-      expect(config.password).toEqual('pass')
-      expect(config.port).toEqual(9821)
-    })
-    it('should work with no authentication options', function() {
-      var sequelize = new Sequelize('mysql://example.com:9821/dbname')
-      var config = sequelize.config
-      expect(config.username).toEqual(undefined)
-      expect(config.password).toEqual(null)
-    })
-    it('should use the default port when no other is specified', function() {
-      var sequelize = new Sequelize('mysql://example.com/dbname')
-      var config = sequelize.config
-      // The default port should be set
-      expect(config.port).toEqual(3306)
-    })
-  })
-  describe('Intantiation with arguments', function() {
-    it('should accept two parameters (database, username)', function() {
-      var sequelize = new Sequelize('dbname', 'root')
-      var config = sequelize.config
-      expect(config.database).toEqual('dbname')
-      expect(config.username).toEqual('root')
-    })
-    it('should accept three parameters (database, username, password)', function() {
-      var sequelize = new Sequelize('dbname', 'root', 'pass')
-      var config = sequelize.config
-      expect(config.database).toEqual('dbname')
-      expect(config.username).toEqual('root')
-      expect(config.password).toEqual('pass')
-    })
-    it('should accept four parameters (database, username, password, options)', function() {
-      var sequelize = new Sequelize('dbname', 'root', 'pass', { port: 999 })
-      var config = sequelize.config
-      expect(config.database).toEqual('dbname')
-      expect(config.username).toEqual('root')
-      expect(config.password).toEqual('pass')
-      expect(config.port).toEqual(999)
-    })
-  })
-})
--- a/spec/dao-factory.spec.js
+++ b/spec/dao-factory.spec.js
--- a/spec/dao.spec.js
+++ b/spec/dao.spec.js
--- a/spec/language.spec.js
+++ b/spec/language.spec.js
-if(typeof require === 'function') {
-  const buster    = require("buster")
-      , Sequelize = require("../index")
-      , Helpers   = require('./buster-helpers')
-      , dialect   = Helpers.getTestDialect()
-}
-buster.spec.expose()
-buster.testRunner.timeout = 1000
-describe(Helpers.getTestDialectTeaser("Language Util"), function() {
-  describe("Plural", function(){
-    before(function(done) {
-      Helpers.initTests({
-        dialect: dialect,
-        onComplete: function(sequelize) {
-          this.sequelize = sequelize
-          this.sequelize.options.language = 'es'
-          done()
-        }.bind(this)
-      })
-    })
-    it("should rename tables to their plural form...", function(done){
-      var table = this.sequelize.define('arbol', {name: Sequelize.STRING})
-      var table2 = this.sequelize.define('androide', {name: Sequelize.STRING})
-      expect(table.tableName).toEqual('arboles')
-      expect(table2.tableName).toEqual('androides')
-      done()
-    })
-    it("should be able to pluralize/singularize associations...", function(done){
-      var table = this.sequelize.define('arbol', {name: Sequelize.STRING})
-      var table2 = this.sequelize.define('androide', {name: Sequelize.STRING})
-      var table3 = this.sequelize.define('hombre', {name: Sequelize.STRING})
-      table.hasOne(table2)
-      table2.belongsTo(table)
-      table3.hasMany(table2)
-      expect(table.associations.androides.identifier).toEqual('arbolId')
-      expect(table2.associations.arboles).toBeDefined()
-      expect(table3.associations.androideshombres).toBeDefined()
-      done()
-    })
-  })
-})
--- a/spec/migrator.spec.js
+++ b/spec/migrator.spec.js
--- a/spec/postgres/hstore.spec.js
+++ b/spec/postgres/hstore.spec.js
-if(typeof require === 'function') {
-  const buster  = require("buster")
-      , Helpers = require('../buster-helpers')
-      , dialect = Helpers.getTestDialect()
-}
-buster.spec.expose()
-if (dialect.match(/^postgres/)) {
-  describe('[POSTGRES] hstore', function() {
-    const hstore = require('../../lib/dialects/postgres/hstore')
-    describe('stringifyPart', function() {
-      it("handles undefined values correctly", function() {
-        expect(hstore.stringifyPart(undefined)).toEqual('NULL')
-      })
-      it("handles null values correctly", function() {
-        expect(hstore.stringifyPart(null)).toEqual('NULL')
-      })
-      it("handles boolean values correctly", function() {
-        expect(hstore.stringifyPart(false)).toEqual('false')
-        expect(hstore.stringifyPart(true)).toEqual('true')
-      })
-      it("handles strings correctly", function() {
-        expect(hstore.stringifyPart('foo')).toEqual('"foo"')
-      })
-      it("handles strings with backslashes correctly", function() {
-        expect(hstore.stringifyPart("\\'literally\\'")).toEqual('"\\\\\'literally\\\\\'"')
-      })
-      it("handles arrays correctly", function() {
-        expect(hstore.stringifyPart([1,['2'],'"3"'])).toEqual('"[1,[\\"2\\"],\\"\\\\\\"3\\\\\\"\\"]"')
-      })
-      it("handles simple objects correctly", function() {
-        expect(hstore.stringifyPart({ test: 'value' })).toEqual('"{\\"test\\":\\"value\\"}"')
-      })
-      it("handles nested objects correctly", function () {
-        expect(hstore.stringifyPart({ test: { nested: 'value' } })).toEqual('"{\\"test\\":{\\"nested\\":\\"value\\"}}"')
-      })
-      it("handles objects correctly", function() {
-        expect(hstore.stringifyPart({test: {nested: {value: {including: '"string"'}}}})).toEqual('"{\\"test\\":{\\"nested\\":{\\"value\\":{\\"including\\":\\"\\\\\\"string\\\\\\"\\"}}}}"')
-      })
-    })
-    describe('stringify', function() {
-      it('should handle empty objects correctly', function() {
-        expect(hstore.stringify({ })).toEqual('')
-      })
-      it('should handle null values correctly', function () {
-        expect(hstore.stringify({ null: null })).toEqual('"null"=>NULL')
-      })
-      it('should handle simple objects correctly', function() {
-        expect(hstore.stringify({ test: 'value' })).toEqual('"test"=>"value"')
-      })
-      it('should handle nested objects correctly', function() {
-        expect(hstore.stringify({ test: { nested: 'value' } })).toEqual('"test"=>"{\\"nested\\":\\"value\\"}"')
-      })
-      it('should handle nested arrays correctly', function() {
-        expect(hstore.stringify({ test: [ 1, '2', [ '"3"' ] ] })).toEqual('"test"=>"[1,\\"2\\",[\\"\\\\\\"3\\\\\\"\\"]]"')
-      })
-      it('should handle multiple keys with different types of values', function() {
-        expect(hstore.stringify({ true: true, false: false, null: null, undefined: undefined, integer: 1, array: [1,'2'], object: { object: 'value' }})).toEqual('"true"=>true,"false"=>false,"null"=>NULL,"undefined"=>NULL,"integer"=>1,"array"=>"[1,\\"2\\"]","object"=>"{\\"object\\":\\"value\\"}"')
-      })
-    })
-    describe('parse', function() {
-      it('should handle empty objects correctly', function() {
-        expect(hstore.parse('')).toEqual({ })
-      })
-      it('should handle simple objects correctly', function() {
-        expect(hstore.parse('"test"=>"value"')).toEqual({ test: 'value' })
-      })
-      it('should handle nested objects correctly', function() {
-        expect(hstore.parse('"test"=>"{\\"nested\\":\\"value\\"}"')).toEqual({ test: { nested: 'value' } })
-      })
-      it('should handle nested arrays correctly', function() {
-        expect(hstore.parse('"test"=>"[1,\\"2\\",[\\"\\\\\\"3\\\\\\"\\"]]"')).toEqual({ test: [ 1, '2', [ '"3"' ] ] })
-      })
-      it('should handle multiple keys with different types of values', function() {
-        expect(hstore.parse('"true"=>true,"false"=>false,"null"=>NULL,"undefined"=>NULL,"integer"=>1,"array"=>"[1,\\"2\\"]","object"=>"{\\"object\\":\\"value\\"}"')).toEqual({ true: true, false: false, null: null, undefined: null, integer: 1, array: [1,'2'], object: { object: 'value' }})
-      })
-    })
-  })
-}
--- a/spec/promise.spec.js
+++ b/spec/promise.spec.js
-if (typeof require === 'function') {
-  const buster  = require("buster")
-      , Helpers = require('./buster-helpers')
-      , dialect = Helpers.getTestDialect()
-      , _ = require('lodash')
-}
-buster.spec.expose()
-describe(Helpers.getTestDialectTeaser("Promise"), function () {
-  before(function (done) {
-    var self = this
-    Helpers.initTests({
-      dialect: dialect,
-      beforeComplete: function (sequelize, DataTypes) {
-        self.sequelize = sequelize
-        self.User      = sequelize.define('User', {
-          username:  { type: DataTypes.STRING },
-          touchedAt: { type: DataTypes.DATE, defaultValue: DataTypes.NOW },
-          aNumber:   { type: DataTypes.INTEGER },
-          bNumber:   { type: DataTypes.INTEGER },
-          validateTest: {
-            type: DataTypes.INTEGER,
-            allowNull: true,
-            validate: {isInt: true}
-          },
-          validateCustom: {
-            type: DataTypes.STRING,
-            allowNull: true,
-            validate: {len: {msg: 'Length failed.', args: [1, 20]}}
-          },
-          dateAllowNullTrue: {
-            type: DataTypes.DATE,
-            allowNull: true
-          }
-        })
-        self.HistoryLog = sequelize.define('HistoryLog', {
-          someText:  { type: DataTypes.STRING },
-          aNumber:   { type: DataTypes.INTEGER },
-          aRandomId: { type: DataTypes.INTEGER }
-        })
-        self.ParanoidUser = sequelize.define('ParanoidUser', {
-          username: { type: DataTypes.STRING }
-        }, {
-          paranoid: true
-        })
-        self.ParanoidUser.hasOne(self.ParanoidUser)
-      },
-      onComplete: function () {
-        self.User.sync({ force: true }).then(function () {
-            return self.HistoryLog.sync({ force: true })
-          }).then(function () {
-            return self.ParanoidUser.sync({force: true })
-          })
-          .then(function () {done()}, done)
-      }
-    })
-  })
-  describe('increment', function () {
-    before(function (done) {
-      this.User.create({ id: 1, aNumber: 0, bNumber: 0 }).done(done)
-    });
-    it('with array', function (done) {
-      var self = this;
-      // Select something
-      this.User.find(1).then(function (user1) {
-        return user1.increment(['aNumber'], 2)
-      }).then(function (user2) {
-        return self.User.find(1)
-      }).then(function (user3) {
-        expect(user3.aNumber).toBe(2);
-        done();
-      }, done);
-    });
-    it('should still work right with other concurrent updates', function (done) {
-      var self = this;
-      // Select something
-      this.User.find(1).then(function (user1) {
-        // Select the user again (simulating a concurrent query)
-        return self.User.find(1).then(function (user2) {
-          return user2.updateAttributes({
-            aNumber: user2.aNumber + 1
-          }).then(function (user3) {
-            return user1.increment(['aNumber'], 2)
-          }).then(function (user4) {
-            return self.User.find(1)
-          }).then(function (user5) {
-            expect(user5.aNumber).toBe(3);
-            done();
-          }, done)
-        });
-      });
-    });
-    it('with key value pair', function (done) {
-      var self = this;
-      // Select something
-      this.User.find(1).then(function (user1) {
-        return user1.increment({ 'aNumber': 1, 'bNumber': 2})
-      }).then(function () {
-        return self.User.find(1)
-      }).then(function (user3) {
-        expect(user3.aNumber).toBe(1);
-        expect(user3.bNumber).toBe(2);
-        done();
-      }, done);
-    });
-  });
-  describe('decrement', function () {
-    before(function (done) {
-      this.User.create({ id: 1, aNumber: 0, bNumber: 0 }).done(done)
-    });
-    it('with array', function (done) {
-      var self = this;
-      // Select something
-      this.User.find(1).then(function (user1) {
-        return user1.decrement(['aNumber'], 2)
-      }).then(function () {
-        return self.User.find(1);
-      }).then(function (user3) {
-        expect(user3.aNumber).toBe(-2);
-        done();
-      }, done);
-    });
-    it('with single field', function (done) {
-      var self = this;
-      // Select something
-      this.User.find(1).then(function (user1) {
-        return user1.decrement(['aNumber'], 2)
-      }).then(function () {
-        return self.User.find(1);
-      }).then(function (user3) {
-        expect(user3.aNumber).toBe(-2);
-        done();
-      }, done);
-    });
-    it('should still work right with other concurrent decrements', function (done) {
-      var self = this;
-      // Select something
-      this.User.find(1).then(function (user1) {
-        var _done = _.after(3, function () {
-          self.User.find(1).then(function (user2) {
-            expect(user2.aNumber).toEqual(-6);
-            done();
-          })
-        });
-        user1.decrement(['aNumber'], 2).done(_done);
-        user1.decrement(['aNumber'], 2).done(_done);
-        user1.decrement(['aNumber'], 2).done(_done);
-      });
-    });
-  });
-  describe('reload', function () {
-    it("should return a reference to the same DAO instead of creating a new one", function (done) {
-      this.User.create({ username: 'John Doe' }).then(function (originalUser) {
-        return originalUser.updateAttributes({ username: 'Doe John' }).then(function () {
-          return originalUser.reload()
-        }).then(function (updatedUser) {
-          expect(originalUser === updatedUser).toBeTrue()
-          done();
-        }, done)
-      })
-    })
-    it("should update the values on all references to the DAO", function (done) {
-      var self = this
-      this.User.create({ username: 'John Doe' }).then(function (originalUser) {
-        return self.User.find(originalUser.id).then(function (updater) {
-          return updater.updateAttributes({ username: 'Doe John' })
-        }).then(function () {
-          // We used a different reference when calling updateAttributes, so originalUser is now out of sync
-          expect(originalUser.username).toEqual('John Doe')
-          return originalUser.reload()
-        }).then(function (updatedUser) {
-          expect(originalUser.username).toEqual('Doe John')
-          expect(updatedUser.username).toEqual('Doe John')
-          done();
-        }, done)
-      })
-    })
-    it("should update the associations as well", function (done) {
-      var Book = this.sequelize.define('Book', { title:   Helpers.Sequelize.STRING })
-        , Page = this.sequelize.define('Page', { content: Helpers.Sequelize.TEXT })
-      Book.hasMany(Page)
-      Page.belongsTo(Book)
-      this.sequelize.sync({ force: true }).then(function () {
-        return Book.create({ title: 'A very old book' })
-      }).then(function (book) {
-        return Page.create({ content: 'om nom nom' }).then(function (page) {
-          return book.setPages([ page ]).then(function () {
-            return Book.find({
-              where: (dialect === 'postgres' ? '"Books"."id"=' : '`Books`.`id`=') + book.id,
-              include: [Page]
-            }).then(function (leBook) {
-              return page.updateAttributes({ content: 'something totally different' }).then(function (page) {
-                expect(leBook.pages[0].content).toEqual('om nom nom')
-                expect(page.content).toEqual('something totally different')
-                return leBook.reload().then(function (leBook) {
-                  expect(leBook.pages[0].content).toEqual('something totally different')
-                  expect(page.content).toEqual('something totally different')
-                  done()
-                })
-              })
-            })
-          })
-        })
-      }, done)
-    })
-  });
-  describe('complete', function () {
-    it("gets triggered if an error occurs", function (done) {
-      this.User.find({ where: "asdasdasd" }).then(null, function (err) {
-        expect(err).toBeDefined()
-        expect(err.message).toBeDefined()
-        done()
-      })
-    })
-    it("gets triggered if everything was ok", function (done) {
-      this.User.count().then(function (result) {
-        expect(result).toBeDefined()
-        done()
-      })
-    })
-  })
-  describe('save', function () {
-    it('should fail a validation upon creating', function (done) {
-      this.User.create({aNumber: 0, validateTest: 'hello'}).then(null, function (err) {
-        expect(err).toBeDefined()
-        expect(err).toBeObject()
-        expect(err.validateTest).toBeArray()
-        expect(err.validateTest[0]).toBeDefined()
-        expect(err.validateTest[0].indexOf('Invalid integer')).toBeGreaterThan(-1);
-        done();
-      });
-    })
-    it('should fail a validation upon building', function (done) {
-      this.User.build({aNumber: 0, validateCustom: 'aaaaaaaaaaaaaaaaaaaaaaaaaa'}).save()
-      .then(null, function (err) {
-        expect(err).toBeDefined()
-        expect(err).toBeObject()
-        expect(err.validateCustom).toBeDefined()
-        expect(err.validateCustom).toBeArray()
-        expect(err.validateCustom[0]).toBeDefined()
-        expect(err.validateCustom[0]).toEqual('Length failed.')
-        done()
-      })
-    })
-    it('should fail a validation when updating', function (done) {
-      this.User.create({aNumber: 0}).then(function (user) {
-        return user.updateAttributes({validateTest: 'hello'})
-      }).then(null, function (err) {
-        expect(err).toBeDefined()
-        expect(err).toBeObject()
-        expect(err.validateTest).toBeDefined()
-        expect(err.validateTest).toBeArray()
-        expect(err.validateTest[0]).toBeDefined()
-        expect(err.validateTest[0].indexOf('Invalid integer')).toBeGreaterThan(-1)
-        done()
-      })
-    })
-  })
-})
--- a/spec/query-interface.spec.js
+++ b/spec/query-interface.spec.js
-if(typeof require === 'function') {
-  const buster             = require("buster")
-      , CustomEventEmitter = require("../lib/emitters/custom-event-emitter")
-      , Helpers            = require('./buster-helpers')
-      , dialect            = Helpers.getTestDialect()
-}
-buster.spec.expose()
-buster.testRunner.timeout = 1000
-describe(Helpers.getTestDialectTeaser("QueryInterface"), function() {
-  before(function(done) {
-    Helpers.initTests({
-      dialect: dialect,
-      beforeComplete: function(sequelize) {
-        this.sequelize = sequelize
-      }.bind(this),
-      onComplete: function() {
-        this.interface = this.sequelize.getQueryInterface()
-        done()
-      }.bind(this)
-    })
-  })
-  describe('dropAllTables', function() {
-    it("should drop all tables", function(done) {
-      this.interface.dropAllTables().complete(function(err) {
-        expect(err).toBeNull()
-        this.interface.showAllTables().complete(function(err, tableNames) {
-          expect(err).toBeNull()
-          expect(tableNames.length).toEqual(0)
-          this.interface.createTable('table', { name: Helpers.Sequelize.STRING }).complete(function(err) {
-            expect(err).toBeNull()
-            this.interface.showAllTables().complete(function(err, tableNames) {
-              expect(err).toBeNull()
-              expect(tableNames.length).toEqual(1)
-              this.interface.dropAllTables().complete(function(err) {
-                expect(err).toBeNull()
-                this.interface.showAllTables().complete(function(err, tableNames) {
-                  expect(err).toBeNull()
-                  expect(tableNames.length).toEqual(0)
-                  done()
-                })
-              }.bind(this))
-            }.bind(this))
-          }.bind(this))
-        }.bind(this))
-      }.bind(this))
-    })
-  })
-  describe('indexes', function() {
-    before(function(done) {
-      this.interface.createTable('User', {
-        username: Helpers.Sequelize.STRING,
-        isAdmin: Helpers.Sequelize.BOOLEAN
-      }).success(done)
-    })
-    it('adds, reads and removes an index to the table', function(done) {
-      this.interface.addIndex('User', ['username', 'isAdmin']).complete(function(err) {
-        expect(err).toBeNull()
-        this.interface.showIndex('User').complete(function(err, indexes) {
-          expect(err).toBeNull()
-          var indexColumns = Helpers.Sequelize.Utils._.uniq(indexes.map(function(index) { return index.name }))
-          expect(indexColumns).toEqual(['user_username_is_admin'])
-          this.interface.removeIndex('User', ['username', 'isAdmin']).complete(function(err) {
-            expect(err).toBeNull()
-            this.interface.showIndex('User').complete(function(err, indexes) {
-              expect(err).toBeNull()
-              indexColumns = Helpers.Sequelize.Utils._.uniq(indexes.map(function(index) { return index.name }))
-              expect(indexColumns).toEqual([])
-              done()
-            })
-          }.bind(this))
-        }.bind(this))
-      }.bind(this))
-    })
-  })
-  describe('describeTable', function() {
-    before(function(done) {
-      this.interface.createTable('User', {
-        username: Helpers.Sequelize.STRING,
-        isAdmin: Helpers.Sequelize.BOOLEAN,
-        enumVals: Helpers.Sequelize.ENUM('hello', 'world')
-      }).success(done)
-    })
-    it('reads the metadata of the table', function(done) {
-      this.interface.describeTable('User').complete(function(err, metadata) {
-        expect(err).toBeNull()
-        var username = metadata.username
-        var isAdmin  = metadata.isAdmin
-        var enumVals = metadata.enumVals
-        expect(username.type).toEqual(dialect === 'postgres' ? 'CHARACTER VARYING' : 'VARCHAR(255)')
-        expect(username.allowNull).toBeTrue()
-        expect(username.defaultValue).toBeNull()
-        expect(isAdmin.type).toEqual(dialect === 'postgres' ? 'BOOLEAN' : 'TINYINT(1)')
-        expect(isAdmin.allowNull).toBeTrue()
-        expect(isAdmin.defaultValue).toBeNull()
-        if (dialect === 'postgres') {
-          expect(enumVals.special).toBeArray();
-          expect(enumVals.special.length).toEqual(2);
-        }
-        done()
-      })
-    })
-  })
-})
--- a/spec/sequelize.spec.js
+++ b/spec/sequelize.spec.js
-if(typeof require === 'function') {
-  const buster  = require("buster")
-      , Helpers = require('./buster-helpers')
-      , dialect = Helpers.getTestDialect()
-}
-var qq = function(str) {
-  if (dialect == 'postgres' || dialect == 'sqlite') {
-    return '"' + str + '"'
-  } else if (dialect == 'mysql') {
-    return '`' + str + '`'
-  } else {
-    return str
-  }
-}
-buster.spec.expose()
-describe(Helpers.getTestDialectTeaser("Sequelize"), function() {
-  before(function(done) {
-    Helpers.initTests({
-      dialect: dialect,
-      beforeComplete: function(sequelize) { this.sequelize = sequelize }.bind(this),
-      onComplete: done
-    })
-  })
-  describe('isDefined', function() {
-    it("returns false if the dao wasn't defined before", function() {
-      expect(this.sequelize.isDefined('Project')).toBeFalse()
-    })
-    it("returns true if the dao was defined before", function() {
-      this.sequelize.define('Project', {
-        name: Helpers.Sequelize.STRING
-      })
-      expect(this.sequelize.isDefined('Project')).toBeTrue()
-    })
-  })
-  describe('query', function() {
-    before(function(done) {
-      this.User = this.sequelize.define('User', {
-        username: Helpers.Sequelize.STRING
-      })
-      this.insertQuery = "INSERT INTO " + qq(this.User.tableName) + " (username, " + qq("createdAt") + ", " + qq("updatedAt") + ") VALUES ('john', '2012-01-01 10:10:10', '2012-01-01 10:10:10')"
-      this.User.sync().success(done).error(function(err) {
-        console(err)
-        done()
-      })
-    })
-    it('executes a query the internal way', function(done) {
-      this.sequelize.query(this.insertQuery, null, { raw: true })
-      .complete(function(err, result) {
-        if (err) {
-          console.log(err)
-        }
-        expect(err).toBeNull()
-        expect(result).toBeNull()
-        done()
-      })
-    })
-    it('executes a query if only the sql is passed', function(done) {
-      this.sequelize.query(this.insertQuery)
-      .complete(function(err, result) {
-        if (err) {
-          console.log(err)
-        }
-        expect(err).toBeNull()
-        expect(result).not.toBeDefined()
-        done()
-      })
-    })
-    it('executes select queries correctly', function(done) {
-      this.sequelize.query(this.insertQuery).success(function() {
-        this.sequelize
-          .query("select * from " + qq(this.User.tableName) + "")
-          .complete(function(err, users) {
-            if (err) {
-              console.log(err)
-            }
-            expect(err).toBeNull()
-            expect(users.map(function(u){ return u.username })).toEqual(['john'])
-            done()
-          })
-      }.bind(this))
-    })
-    it('executes select query and parses dot notation results', function(done) {
-      this.sequelize.query(this.insertQuery).success(function() {
-        this.sequelize
-          .query("select username as " + qq("user.username") + " from " + qq(this.User.tableName) + "")
-          .complete(function(err, users) {
-            if (err) {
-              console.log(err)
-            }
-            expect(err).toBeNull()
-            expect(users.map(function(u){ return u.user })).toEqual([{'username':'john'}])
-            done()
-          })
-      }.bind(this))
-    })
-    if (dialect == 'mysql') {
-      it('executes stored procedures', function(done) {
-        this.sequelize.query(this.insertQuery).success(function() {
-          this.sequelize.query('DROP PROCEDURE IF EXISTS foo').success(function() {
-            this.sequelize.query(
-              "CREATE PROCEDURE foo()\nSELECT * FROM " + this.User.tableName + ";"
-            ).success(function() {
-              this.sequelize.query('CALL foo()').success(function(users) {
-                expect(users.map(function(u){ return u.username })).toEqual(['john'])
-                done()
-              })
-            }.bind(this))
-          }.bind(this))
-        }.bind(this))
-      })
-    } else {
-      console.log('FIXME: I want to be supported in this dialect as well :-(')
-    }
-    it('uses the passed DAOFactory', function(done) {
-      this.sequelize.query(this.insertQuery).success(function() {
-        this.sequelize.query("SELECT * FROM " + qq(this.User.tableName) + ";", this.User).success(function(users) {
-          expect(users[0].__factory).toEqual(this.User)
-          done()
-        }.bind(this))
-      }.bind(this))
-    })
-    it('destructs dot separated attributes when doing a raw query', function(done) {
-      var tickChar = (dialect === 'postgres') ? '"' : '`'
-        , sql      = "select 1 as " + Helpers.Sequelize.Utils.addTicks('foo.bar.baz', tickChar)
-      this.sequelize.query(sql, null, { raw: true }).success(function(result) {
-        expect(result).toEqual([ { foo: { bar: { baz: 1 } } } ])
-        done()
-      })
-    })
-    it('replaces token with the passed array', function(done) {
-      this.sequelize.query('select ? as foo, ? as bar', null, { raw: true }, [ 1, 2 ]).success(function(result) {
-        expect(result).toEqual([{ foo: 1, bar: 2 }])
-        done()
-      })
-    })
-  })
-  describe('define', function() {
-    [
-      { type: Helpers.Sequelize.ENUM, values: ['scheduled', 'active', 'finished']},
-      Helpers.Sequelize.ENUM('scheduled', 'active', 'finished')
-    ].forEach(function(status) {
-      describe('enum', function() {
-        before(function(done) {
-          this.Review = this.sequelize.define('review', { status: status })
-          this.Review.sync({ force: true }).success(done)
-        })
-        it('raises an error if no values are defined', function() {
-          Helpers.assertException(function() {
-            this.sequelize.define('omnomnom', {
-              bla: { type: Helpers.Sequelize.ENUM }
-            })
-          }.bind(this), 'Values for ENUM haven\'t been defined.')
-        })
-        it('correctly stores values', function(done) {
-          this.Review.create({ status: 'active' }).success(function(review) {
-            expect(review.status).toEqual('active')
-            done()
-          })
-        })
-        it('correctly loads values', function(done) {
-          this.Review.create({ status: 'active' }).success(function() {
-            this.Review.findAll().success(function(reviews) {
-              expect(reviews[0].status).toEqual('active')
-              done()
-            })
-          }.bind(this))
-        })
-        it("doesn't save an instance if value is not in the range of enums", function() {
-          Helpers.assertException(function() {
-            this.Review.create({ status: 'fnord' })
-          }.bind(this), 'Value "fnord" for ENUM status is out of allowed scope. Allowed values: scheduled, active, finished')
-        })
-      })
-    })
-    describe('table', function() {
-      [
-        { id: { type: Helpers.Sequelize.BIGINT } },
-        { id: { type: Helpers.Sequelize.STRING, allowNull: true } },
-        { id: { type: Helpers.Sequelize.BIGINT, allowNull: false, primaryKey: true, autoIncrement: true } }
-      ].forEach(function(customAttributes) {
-        it('should be able to override options on the default attributes', function(done) {
-          var Picture = this.sequelize.define('picture', Helpers.Sequelize.Utils._.cloneDeep(customAttributes))
-          Picture.sync({ force: true }).success(function() {
-            Object.keys(customAttributes).forEach(function(attribute) {
-              Object.keys(customAttributes[attribute]).forEach(function(option) {
-                var optionValue = customAttributes[attribute][option];
-                expect(Picture.rawAttributes[attribute][option]).toBe(optionValue)
-              });
-            })
-            done()
-          })
-        })
-      })
-    })
-  })
-})
--- a/spec/assets/migrations/20111117063700-createPerson.js
+++ b/spec/assets/migrations/20111117063700-createPerson.js
--- a/spec/assets/migrations/20111130161100-emptyMigration.js
+++ b/spec/assets/migrations/20111130161100-emptyMigration.js
--- a/spec/assets/migrations/20111205064000-renamePersonToUser.js
+++ b/spec/assets/migrations/20111205064000-renamePersonToUser.js
--- a/spec/assets/migrations/20111205162700-addSignatureColumnToUser.js
+++ b/spec/assets/migrations/20111205162700-addSignatureColumnToUser.js
--- a/spec/assets/migrations/20111206061400-removeShopIdColumnFromUser.js
+++ b/spec/assets/migrations/20111206061400-removeShopIdColumnFromUser.js
--- a/spec/assets/migrations/20111206063000-changeSignatureColumnOfUserToMendatory.js
+++ b/spec/assets/migrations/20111206063000-changeSignatureColumnOfUserToMendatory.js
--- a/spec/assets/migrations/20111206163300-renameSignatureColumnOfUserToSig.js
+++ b/spec/assets/migrations/20111206163300-renameSignatureColumnOfUserToSig.js
--- a/spec-jasmine/assets/project.js
+++ b/spec-jasmine/assets/project.js
--- a/spec/config/config.js
+++ b/spec/config/config.js
--- a/test/configuration.test.js
+++ b/test/configuration.test.js
--- a/test/dao-factory.test.js
+++ b/test/dao-factory.test.js
--- a/test/dao.test.js
+++ b/test/dao.test.js
--- a/spec/dao.validations.spec.js
+++ b/spec/dao.validations.spec.js
--- a/spec/data-types.spec.js
+++ b/spec/data-types.spec.js
--- a/spec/emitters/custom-event-emitter.spec.js
+++ b/spec/emitters/custom-event-emitter.spec.js
--- a/test/language.test.js
+++ b/test/language.test.js
--- a/test/migrator.test.js
+++ b/test/migrator.test.js
--- a/test/mysql/associations.test.js
+++ b/test/mysql/associations.test.js
--- a/test/mysql/connector-manager.test.js
+++ b/test/mysql/connector-manager.test.js
--- a/test/mysql/dao-factory.test.js
+++ b/test/mysql/dao-factory.test.js
--- a/spec-jasmine/mysql/query-generator.spec.js
+++ b/spec-jasmine/mysql/query-generator.spec.js
--- a/test/postgres/associations.test.js
+++ b/test/postgres/associations.test.js
--- a/spec/postgres/dao.spec.js
+++ b/spec/postgres/dao.spec.js
--- a/test/postgres/hstore.test.js
+++ b/test/postgres/hstore.test.js
--- a/spec-jasmine/postgres/query-generator.spec.js
+++ b/spec-jasmine/postgres/query-generator.spec.js
--- a/test/promise.test.js
+++ b/test/promise.test.js
--- a/spec/query-chainer.spec.js
+++ b/spec/query-chainer.spec.js
--- a/test/query-generator.test.js
+++ b/test/query-generator.test.js
--- a/test/query-interface.test.js
+++ b/test/query-interface.test.js
--- a/test/sequelize.test.js
+++ b/test/sequelize.test.js
--- a/test/sqlite/dao-factory.test.js
+++ b/test/sqlite/dao-factory.test.js
--- a/spec/sqlite/dao.spec.js
+++ b/spec/sqlite/dao.spec.js
--- a/spec-jasmine/sqlite/query-generator.spec.js
+++ b/spec-jasmine/sqlite/query-generator.spec.js
--- a/test/sqlite/test.sqlite
+++ b/test/sqlite/test.sqlite
--- a/spec/buster-helpers.js
+++ b/spec/buster-helpers.js
--- a/test/utils.test.js
+++ b/test/utils.test.js