Merge branch 'master' of github.com:sequelize/sequelize

changelog.md

@@ -17,6 +17,9 @@
 - [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] 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
@@ -30,11 +33,14 @@
 - [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
+- [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

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

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
+    });
+};

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
+    });
+};

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
+    });
+};

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
+```

lib/dao-factory.js

@@ -278,6 +278,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

lib/dialects/mysql/query-generator.js

 var Utils     = require("../../utils")
   , DataTypes = require("../../data-types")
+  , SqlString = require("../../sql-string")
   , util      = require("util")
 
 module.exports = (function() {
@@ -217,8 +218,14 @@ module.exports = (function() {
         query += " ORDER BY " + options.order
       }
 
-
-      if (options.limit && !(options.include && (options.limit === 1))) {
+      if (options.offset && !options.limit) {
+        /*
+         * 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 {
@@ -431,11 +438,24 @@ module.exports = (function() {
 
           result.push([_key, _value].join(" IN "))
         } else if ((value) && (typeof value == 'object') && !(value instanceof Date)) {
-          // is value an object?
-          
-          //using as sentinel for join column => value
-          _value = this.quoteIdentifiers(value.join)
-          result.push([_key, _value].join("="))
+          if (!!value.join) {
+            //using as sentinel for join column => value
+            _value = this.quoteIdentifiers(value.join)
+            result.push([_key, _value].join("="))
+          } else {
+            for (var logic in value) {
+              var logicResult = this.getWhereLogic(logic)
+              if (logicResult === "BETWEEN" || logicResult === "NOT BETWEEN") {
+                _value = this.escape(value[logic][0])
+                var _value2 = this.escape(value[logic][1])
+
+                result.push(' (' + _key + ' ' + logicResult + ' ' + _value + ' AND ' + _value2 + ') ')
+              } else {
+                _value = this.escape(value[logic])
+                result.push([_key, _value].join(' ' + logicResult + ' '))
+              }
+            }
+          }
         } else {
           _value = this.escape(value)
           result.push((_value == 'NULL') ? _key + " IS NULL" : [_key, _value].join("="))
@@ -445,6 +465,33 @@ module.exports = (function() {
       return result.join(" AND ")
     },
 
+    getWhereLogic: function(logic) {
+      switch (logic) {
+      case 'gte':
+        return '>='
+        break
+      case 'gt':
+        return '>'
+        break
+      case 'lte':
+        return '<='
+        break
+      case 'lt':
+        return '<'
+        break
+      case 'ne':
+        return '!='
+        break
+      case 'between':
+        return 'BETWEEN'
+        break
+      case 'nbetween':
+      case 'notbetween':
+        return 'NOT BETWEEN'
+        break
+      }
+    },
+
     attributesToSQL: function(attributes) {
       var result = {}
 
@@ -507,7 +554,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
@@ -554,12 +601,7 @@ module.exports = (function() {
     },
 
     escape: function(value) {
-      if (value instanceof Date) {
-        value = Utils.toSqlDate(value)
-      } else if (typeof value === 'boolean') {
-        value = value ? 1 : 0
-      }
-      return Utils.escape(value)
+      return SqlString.escape(value, false, null, "mysql")
     }
 
   }

lib/dialects/postgres/connector-manager.js

@@ -10,6 +10,10 @@ module.exports = (function() {
     this.pooling      = (!!this.config.poolCfg && (this.config.poolCfg.maxConnections > 0))
     this.pg           = this.config.native ? require('pg').native : require('pg')
 
+    // 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

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 = {
@@ -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]) {
@@ -522,9 +521,24 @@ module.exports = (function() {
           result.push([_key, _value].join(" IN "))
         }
         else if ((value) && (typeof value === "object")) {
-          //using as sentinel for join column => value
-          _value = this.quoteIdentifiers(value.join)
-          result.push([_key, _value].join("="))
+          if (!!value.join) {
+            //using as sentinel for join column => value
+            _value = this.quoteIdentifiers(value.join)
+            result.push([_key, _value].join("="))
+          } else {
+            for (var logic in value) {
+              var logicResult = this.getWhereLogic(logic)
+              if (logicResult === "BETWEEN" || logicResult === "NOT BETWEEN") {
+                _value = this.escape(value[logic][0])
+                var _value2 = this.escape(value[logic][1])
+
+                result.push(' (' + _key + ' ' + logicResult + ' ' + _value + ' AND ' + _value2 + ') ')
+              } else {
+                _value = this.escape(value[logic])
+                result.push([_key, _value].join(' ' + logicResult + ' '))
+              }
+            }
+          }
         } else {
           _value = this.escape(value)
           result.push((_value == 'NULL') ? _key + " IS NULL" : [_key, _value].join("="))
@@ -534,6 +548,33 @@ module.exports = (function() {
       return result.join(' AND ')
     },
 
+    getWhereLogic: function(logic) {
+      switch (logic) {
+      case 'gte':
+        return '>='
+        break
+      case 'gt':
+        return '>'
+        break
+      case 'lte':
+        return '<='
+        break
+      case 'lt':
+        return '<'
+        break
+      case 'ne':
+        return '!='
+        break
+      case 'between':
+        return 'BETWEEN'
+        break
+      case 'nbetween':
+      case 'notbetween':
+        return 'NOT BETWEEN'
+        break
+      }
+    },
+
     attributesToSQL: function(attributes) {
       var result = {}
 
@@ -683,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)
@@ -737,33 +774,8 @@ module.exports = (function() {
       return identifiers.split('.').map(function(t) { return this.quoteIdentifier(t, force) }.bind(this)).join('.')
     },
 
-    escape: function (val, field) {
-      if (val === undefined || val === null) {
-        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 + "'";
+    escape: function(value, field) {
+      return SqlString.escape(value, false, null, "postgres", field)
     }
 
   }

lib/dialects/postgres/query.js

@@ -111,7 +111,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) {

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")),
@@ -188,8 +189,13 @@ module.exports = (function() {
         query += " ORDER BY " + options.order
       }
 
-
-      if (options.limit && !(options.include && (options.limit === 1))) {
+      if (options.offset && !options.limit) {
+        /*
+         * 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 {
@@ -448,19 +454,7 @@ module.exports = (function() {
     },
 
     escape: function(value) {
-      if (value instanceof Date) {
-        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;
-      }
+      return SqlString.escape(value, false, null, "sqlite")
     }
 
   }

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.filename       = Utils._.last(this.path.split('/'))
+    this.path           = path.normalize(p)
+    this.filename       = Utils._.last(this.path.split(path.sep))
 
     var parsed          = Migration.parseFilename(this.filename)
 

lib/migrator.js

@@ -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() {

lib/sequelize.js

@@ -102,7 +102,11 @@ module.exports = (function() {
       maxConcurrentQueries: this.options.maxConcurrentQueries
     }
 
-    var ConnectorManager = require("./dialects/" + this.options.dialect + "/connector-manager")
+    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)

lib/sql-string.js

-var SqlString = exports;
+var moment = require("moment")
+  , SqlString = exports;
 
 SqlString.escapeId = function (val, forbidQualified) {
   if (forbidQualified) {
@@ -7,18 +8,22 @@ 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 (val === undefined || val === null) {
     return 'NULL';
   }
 
   switch (typeof val) {
-    case 'boolean': return (val) ? 'true' : 'false';
+    case 'boolean':
+      // 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 +31,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 +42,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 +62,22 @@ SqlString.escape = function(val, stringifyObjects, timeZone, dialect) {
   return "'"+val+"'";
 };
 
-SqlString.arrayToList = function(array, timeZone) {
-  return array.map(function(v) {
-    if (Array.isArray(v)) return '(' + SqlString.arrayToList(v) + ')';
-    return SqlString.escape(v, true, timeZone);
-  }).join(', ');
+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, timeZone, dialect) + ')';
+      return SqlString.escape(v, true, timeZone, dialect);
+    }).join(', ');
+  }
 };
 
 SqlString.format = function(sql, values, timeZone, dialect) {
@@ -75,10 +92,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).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 +109,7 @@ SqlString.dateToString = function(date, timeZone) {
     }
   }
 
-  var year   = dt.getFullYear();
-  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;
+  return moment(dt).format("YYYY-MM-DD HH:mm:ss");
 };
 
 SqlString.bufferToString = function(buffer) {

lib/utils.js

@@ -42,17 +42,6 @@ var Utils = module.exports = {
   isHash: function(obj) {
     return Utils._.isObject(obj) && !Array.isArray(obj);
   },
-  pad: function (s) {
-    return s < 10 ? '0' + s : s
-  },
-  toSqlDate: function(date) {
-    return date.getUTCFullYear() + '-' +
-      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)
     if (result) {
@@ -181,12 +170,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.QueryChainer = require("./query-chainer")
-Utils.Lingo = require("lingo")
\ No newline at end of file
+Utils.Lingo = require("lingo")

package.json

@@ -50,7 +50,8 @@
     "pg": "~2.0.0",
     "buster": "~0.6.3",
     "watchr": "~2.2.0",
-    "yuidocjs": "~0.3.36"
+    "yuidocjs": "~0.3.36",
+    "semver": "~2.0.8"
   },
   "keywords": [
     "mysql",

spec-jasmine/dao-factory.spec.js

@@ -238,9 +238,7 @@ describe('DAOFactory', function() {
             })
           })
         })
-
-/*
-// at time of writing (v1.6.0) Sequelize does not seem to support 'offset' on it's own consistently (goes wrong for PostGRES and SQLite)
+        
         it("handles offset", function() {
           Helpers.async(function(done) {
             User.findAndCountAll({offset: 1}).success(function(info) {
@@ -251,7 +249,7 @@ describe('DAOFactory', function() {
             })
           })
         })
-*/
+
         it("handles limit", function() {
           Helpers.async(function(done) {
             User.findAndCountAll({limit: 1}).success(function(info) {

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

@@ -178,9 +178,9 @@ describe('QueryGenerator', function() {
         expectation: "SELECT * FROM `myTable` LIMIT 2, 10;",
         context: QueryGenerator
       }, {
-        title: 'ignores offset if no limit was passed',
+        title: 'uses default limit if only offset is specified',
         arguments: ['myTable', {offset: 2}],
-        expectation: "SELECT * FROM `myTable`;",
+        expectation: "SELECT * FROM `myTable` LIMIT 2, 18440000000000000000;",
         context: QueryGenerator
       }, {
         title: 'multiple where arguments',
@@ -235,10 +235,10 @@ describe('QueryGenerator', function() {
         context: {options: {omitNull: true}}
       }, {
         arguments: ['myTable', {foo: false}],
-        expectation: "INSERT INTO `myTable` (`foo`) VALUES (0);"
+        expectation: "INSERT INTO `myTable` (`foo`) VALUES (false);"
       }, {
         arguments: ['myTable', {foo: true}],
-        expectation: "INSERT INTO `myTable` (`foo`) VALUES (1);"
+        expectation: "INSERT INTO `myTable` (`foo`) VALUES (true);"
       }
     ],
 
@@ -272,7 +272,7 @@ describe('QueryGenerator', function() {
         context: {options: {omitNull: true}} // Note: As above
       }, {
         arguments: ['myTable', [{name: "foo", value: true}, {name: 'bar', value: false}]],
-        expectation: "INSERT INTO `myTable` (`name`,`value`) VALUES ('foo',1),('bar',0);"
+        expectation: "INSERT INTO `myTable` (`name`,`value`) VALUES ('foo',true),('bar',false);"
       }
     ],
 
@@ -302,10 +302,10 @@ describe('QueryGenerator', function() {
         context: {options: {omitNull: true}}
       }, {
         arguments: ['myTable', {bar: false}, {name: 'foo'}],
-        expectation: "UPDATE `myTable` SET `bar`=0 WHERE `name`='foo'"
+        expectation: "UPDATE `myTable` SET `bar`=false WHERE `name`='foo'"
       }, {
         arguments: ['myTable', {bar: true}, {name: 'foo'}],
-        expectation: "UPDATE `myTable` SET `bar`=1 WHERE `name`='foo'"
+        expectation: "UPDATE `myTable` SET `bar`=true WHERE `name`='foo'"
       }
     ],
 
@@ -385,11 +385,11 @@ describe('QueryGenerator', function() {
       },
       {
         arguments: [{ maple: false, bacon: true }],
-        expectation: "`maple`=0 AND `bacon`=1"
+        expectation: "`maple`=false AND `bacon`=true"
       },
       {
         arguments: [{ beaver: [false, true] }],
-        expectation: "`beaver` IN (0,1)"
+        expectation: "`beaver` IN (false,true)"
       },
       {
         arguments: [{birthday: new Date(Date.UTC(2011, 6, 1, 10, 1, 55))}],

spec/buster-helpers.js

@@ -34,7 +34,7 @@ var BusterHelpers = module.exports = {
     var sequelizeOptions = {
       logging: options.logging,
       dialect: options.dialect,
-      port:    config[options.dialect].port
+      port:    process.env.SEQ_PORT || config[options.dialect].port
     }
 
     if (process.env.DIALECT === 'postgres-native') {
@@ -42,9 +42,9 @@ var BusterHelpers = module.exports = {
     }
 
     return new Sequelize(
-      config[options.dialect].database,
-      config[options.dialect].username,
-      config[options.dialect].password,
+      process.env.SEQ_DB    || config[options.dialect].database,
+      process.env.SEQ_USER  || process.env.SEQ_USERNAME || config[options.dialect].username,
+      process.env.SEQ_PW    || process.env.SEQ_PASSWORD || config[options.dialect].password,
       sequelizeOptions
     )
   },

spec/configuration.spec.js

 if(typeof require === 'function') {
   const buster           = require("buster")
+    , semver             = require("semver")
     , CustomEventEmitter = require("../lib/emitters/custom-event-emitter")
     , Helpers            = require('./buster-helpers')
     , config             = require(__dirname + "/config/config")
@@ -10,27 +11,22 @@ buster.spec.expose()
 buster.testRunner.timeout = 1000
 
 var Sequelize = require(__dirname + '/../index')
+  , noDomains = semver.lt(process.version, '0.8.0')
 
 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')
+    it('when we don\'t have the correct server details', function(done) {
+      if (noDomains === true) {
+        console.log('WARNING: Configuration specs requires NodeJS version >= 0.8 for full compatibility')
         expect('').toEqual('') // Silence Buster!
-        done()
+        return 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)
+        , domain = require('domain')
+        , d = domain.create()
 
       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.'
@@ -40,39 +36,35 @@ describe(Helpers.getTestDialectTeaser("Configuration"), function() {
         }
 
         expect(err.message).toEqual(msg)
+        d.remove(sequelize.query)
         done()
       })
 
       d.run(function(){
+        d.add(sequelize.query)
         sequelize.query('select 1 as hello')
         .success(function(){})
       })
     })
 
-    it('should give us an error for not having the correct login information', function(done) {
+    it('when we don\'t have the correct login information', function(done) {
       if (dialect !== "postgres" && dialect !== "postgres-native" && dialect !== "mysql") {
-        // This dialect doesn't support incorrect login information
+        console.log('This dialect doesn\'t support me :(')
         expect('').toEqual('') // Silence Buster
         return done()
       }
 
-      var domain
-
-      try {
-        domain = require('domain')
-      } catch (err) {
-        console.log('WARNING: Configuration specs requires Node version >= 0.8')
+      if (noDomains === true) {
+        console.log('WARNING: Configuration specs requires NodeJS version >= 0.8 for full compatibility')
         expect('').toEqual('') // Silence Buster!
-        done()
+        return 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)
+      , domain = require('domain')
+      , d = domain.create()
 
       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.'
@@ -82,14 +74,22 @@ describe(Helpers.getTestDialectTeaser("Configuration"), function() {
         }
 
         expect(err.message).toEqual(msg)
+        d.remove(sequelize.query)
         done()
       })
 
       d.run(function(){
+        d.add(sequelize.query)
         sequelize.query('select 1 as hello')
         .success(function(){})
       })
     })
+
+    it('when we don\'t have a valid dialect.', function() {
+      Helpers.assertException(function() {
+        new Sequelize(config[dialect].database, config[dialect].username, config[dialect].password, {host: '0.0.0.1', port: config[dialect].port, dialect: undefined})
+      }.bind(this), 'The dialect undefined is not supported.')
+    })
   })
 
   describe('Instantiation with a URL string', function() {

spec/dao-factory.spec.js

@@ -14,11 +14,14 @@ describe(Helpers.getTestDialectTeaser("DAOFactory"), function() {
     Helpers.initTests({
       dialect: dialect,
       beforeComplete: function(sequelize, DataTypes) {
+        this.DataTypes = DataTypes
         this.sequelize = sequelize
         this.User      = sequelize.define('User', {
           username:     DataTypes.STRING,
           secretValue:  DataTypes.STRING,
-          data:         DataTypes.STRING
+          data:         DataTypes.STRING,
+          intVal:       DataTypes.INTEGER,
+          theDate:      DataTypes.DATE
         })
       }.bind(this),
       onComplete: function() {
@@ -807,7 +810,8 @@ describe(Helpers.getTestDialectTeaser("DAOFactory"), function() {
         , User = this.sequelize.define('ParanoidUser', {
             username:     Sequelize.STRING,
             secretValue:  Sequelize.STRING,
-            data:         Sequelize.STRING
+            data:         Sequelize.STRING,
+            intVal:       { type: Sequelize.INTEGER, defaultValue: 1}
           }, {
             paranoid: true
           })
@@ -842,16 +846,251 @@ describe(Helpers.getTestDialectTeaser("DAOFactory"), function() {
 
   }) // - destroy
 
+  describe('special where conditions', function() {
+    before(function(done) {
+      var self = this
+
+      this.User.create({
+        username: 'boo',
+        intVal: 5,
+        theDate: '2013-01-01 12:00'
+      }).success(function(user){
+        self.user = user
+        self.User.create({
+          username: 'boo2',
+          intVal: 10,
+          theDate: '2013-01-10 12:00'
+        }).success(function(user2){
+          self.user2 = user2
+          done()
+        })
+      })
+    })
+
+    it('should be able to find a row between a certain date', function(done) {
+      this.User.findAll({
+        where: {
+          theDate: {
+            between: ['2013-01-02', '2013-01-11']
+          }
+        }
+      }).success(function(users) {
+        expect(users[0].username).toEqual('boo2')
+        expect(users[0].intVal).toEqual(10)
+        done()
+      })
+    })
+
+    it('should be able to find a row between a certain date and an additional where clause', function(done) {
+      this.User.findAll({
+        where: {
+          theDate: {
+            between: ['2013-01-02', '2013-01-11']
+          },
+          intVal: 10
+        }
+      }).success(function(users) {
+        expect(users[0].username).toEqual('boo2')
+        expect(users[0].intVal).toEqual(10)
+        done()
+      })
+    })
+
+    it('should be able to find a row not between a certain integer', function(done) {
+      this.User.findAll({
+        where: {
+          intVal: {
+            nbetween: [8, 10]
+          }
+        }
+      }).success(function(users) {
+        expect(users[0].username).toEqual('boo')
+        expect(users[0].intVal).toEqual(5)
+        done()
+      })
+    })
+
+    it('should be able to find a row using not between and between logic', function(done) {
+      this.User.findAll({
+        where: {
+          theDate: {
+            between: ['2012-12-10', '2013-01-02'],
+            nbetween: ['2013-01-04', '2013-01-20']
+          }
+        }
+      }).success(function(users) {
+        expect(users[0].username).toEqual('boo')
+        expect(users[0].intVal).toEqual(5)
+        done()
+      })
+    })
+
+    it('should be able to find a row using not between and between logic with dates', function(done) {
+      this.User.findAll({
+        where: {
+          theDate: {
+            between: [new Date('2012-12-10'), new Date('2013-01-02')],
+            nbetween: [new Date('2013-01-04'), new Date('2013-01-20')]
+          }
+        }
+      }).success(function(users) {
+        expect(users[0].username).toEqual('boo')
+        expect(users[0].intVal).toEqual(5)
+        done()
+      })
+    })
+
+    it('should be able to find a row using greater than or equal to logic with dates', function(done) {
+      this.User.findAll({
+        where: {
+          theDate: {
+            gte: new Date('2013-01-09')
+          }
+        }
+      }).success(function(users) {
+        expect(users[0].username).toEqual('boo2')
+        expect(users[0].intVal).toEqual(10)
+        done()
+      })
+    })
+
+    it('should be able to find a row using greater than or equal to', function(done) {
+      this.User.find({
+        where: {
+          intVal: {
+            gte: 6
+          }
+        }
+      }).success(function(user) {
+        expect(user.username).toEqual('boo2')
+        expect(user.intVal).toEqual(10)
+        done()
+      })
+    })
+
+    it('should be able to find a row using greater than', function(done) {
+      this.User.find({
+        where: {
+          intVal: {
+            gt: 5
+          }
+        }
+      }).success(function(user) {
+        expect(user.username).toEqual('boo2')
+        expect(user.intVal).toEqual(10)
+        done()
+      })
+    })
+
+    it('should be able to find a row using lesser than or equal to', function(done) {
+      this.User.find({
+        where: {
+          intVal: {
+            lte: 5
+          }
+        }
+      }).success(function(user) {
+        expect(user.username).toEqual('boo')
+        expect(user.intVal).toEqual(5)
+        done()
+      })
+    })
+
+    it('should be able to find a row using lesser than', function(done) {
+      this.User.find({
+        where: {
+          intVal: {
+            lt: 6
+          }
+        }
+      }).success(function(user) {
+        expect(user.username).toEqual('boo')
+        expect(user.intVal).toEqual(5)
+        done()
+      })
+    })
+
+    it('should have no problem finding a row using lesser and greater than', function(done) {
+      this.User.findAll({
+        where: {
+          intVal: {
+            lt: 6,
+            gt: 4
+          }
+        }
+      }).success(function(users) {
+        expect(users[0].username).toEqual('boo')
+        expect(users[0].intVal).toEqual(5)
+        done()
+      })
+    })
+
+    it('should be able to find a row using not equal to logic', function(done) {
+      this.User.find({
+        where: {
+          intVal: {
+            ne: 10
+          }
+        }
+      }).success(function(user) {
+        expect(user.username).toEqual('boo')
+        expect(user.intVal).toEqual(5)
+        done()
+      })
+    })
+
+    it('should be able to find multiple users with any of the special where logic properties', function(done) {
+      this.User.findAll({
+        where: {
+          intVal: {
+            lte: 10
+          }
+        }
+      }).success(function(users) {
+        expect(users[0].username).toEqual('boo')
+        expect(users[0].intVal).toEqual(5)
+        expect(users[1].username).toEqual('boo2')
+        expect(users[1].intVal).toEqual(10)
+        done()
+      })
+    })
+  })
+
   describe('find', function find() {
     before(function(done) {
       this.User.create({
         username: 'barfooz'
       }).success(function(user) {
-        this.user = user
-        done()
+        this.UserPrimary = this.sequelize.define('UserPrimary', {
+          specialKey: {
+            type: this.DataTypes.STRING,
+            primaryKey: true
+          }
+        })
+
+        this.UserPrimary.sync({force: true}).success(function(primary){
+          this.UserPrimary.create({specialKey: 'a string'}).success(function(){
+            this.user = user
+            done()
+          }.bind(this))
+        }.bind(this))
       }.bind(this))
     })
 
+    it('doesn\'t throw an error when entering in a non integer value for a specified primary field', function(done) {
+      this.UserPrimary.find('a string').success(function(user) {
+        expect(user.specialKey).toEqual('a string')
+        done()
+      })
+    })
+
+    it('doesn\'t throw an error when entering in a non integer value', function(done) {
+      this.User.find('a string value').success(function(user) {
+        expect(user).toBeNull()
+        done()
+      })
+    })
+
     it('returns a single dao', function(done) {
       this.User.find(this.user.id).success(function(user) {
         expect(Array.isArray(user)).toBeFalsy()

spec/sequelize.spec.js

@@ -91,6 +91,22 @@ describe(Helpers.getTestDialectTeaser("Sequelize"), function() {
       }.bind(this))
     })
 
+    it('executes select queries correctly when quoteIdentifiers is false', function(done) {
+      this.sequelize.options.quoteIdentifiers = false
+      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