Merge branch 'blob' of https://github.com/janmeier/sequelize into janmeier-blob

changelog.md

@@ -56,6 +56,7 @@
 - [FEATURE] bulkCreate() now has a third argument which gives you the ability to validate each row before attempting to bulkInsert [#797](https://github.com/sequelize/sequelize/pull/797). thanks to durango
 - [FEATURE] Added `isDirty` to model instances. [#798](https://github.com/sequelize/sequelize/pull/798). Thanks to mstorgaard
 - [FEATURE] Added possibility to use env variable for the database connection. [#784](https://github.com/sequelize/sequelize/pull/784). Thanks to sykopomp.
+- [FEATURE] Blob support. janmeier
 - [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
 - [REFACTORING] Moved Jasmine to Buster and then Buster to Mocha + Chai. sdepold and durango

lib/data-types.js

 var STRING = function(length, binary) {
   if (this instanceof STRING) {
-    this._binary = !!binary;
+    this._binary = !!binary
     if (typeof length === 'number') {
-      this._length = length;
+      this._length = length
     } else {
-      this._length = 255;
+      this._length = 255
     }
   } else {
-    return new STRING(length, binary);
+    return new STRING(length, binary)
   }
-};
+}
 
 STRING.prototype = {
   get BINARY() {
-    this._binary = true;
-    return this;
+    this._binary = true
+    return this
   },
   get type() {
-    return this.toString();
+    return this.toString()
   },
   toString: function() {
-    return 'VARCHAR(' + this._length + ')' + ((this._binary) ? ' BINARY' : '');
+    return 'VARCHAR(' + this._length + ')' + ((this._binary) ? ' BINARY' : '')
   }
-};
+}
 
 Object.defineProperty(STRING, 'BINARY', {
   get: function() {
-    return new STRING(undefined, true);
+    return new STRING(undefined, true)
   }
-});
+})
 
 var INTEGER = function() {
-  return INTEGER.prototype.construct.apply(this, [INTEGER].concat(Array.prototype.slice.apply(arguments)));
-};
+  return INTEGER.prototype.construct.apply(this, [INTEGER].concat(Array.prototype.slice.apply(arguments)))
+}
 
 var BIGINT = function() {
-  return BIGINT.prototype.construct.apply(this, [BIGINT].concat(Array.prototype.slice.apply(arguments)));
-};
+  return BIGINT.prototype.construct.apply(this, [BIGINT].concat(Array.prototype.slice.apply(arguments)))
+}
 
 var FLOAT = function() {
-  return FLOAT.prototype.construct.apply(this, [FLOAT].concat(Array.prototype.slice.apply(arguments)));
-};
-
-FLOAT._type = FLOAT;
-FLOAT._typeName = 'FLOAT';
-INTEGER._type = INTEGER;
-INTEGER._typeName = 'INTEGER';
-BIGINT._type = BIGINT;
-BIGINT._typeName = 'BIGINT';
-STRING._type = STRING;
-STRING._typeName = 'VARCHAR';
-
-STRING.toString = INTEGER.toString = FLOAT.toString = BIGINT.toString = function() {
-  return new this._type().toString();
-};
+  return FLOAT.prototype.construct.apply(this, [FLOAT].concat(Array.prototype.slice.apply(arguments)))
+}
+
+var BLOB = function() {
+  return BLOB.prototype.construct.apply(this, [BLOB].concat(Array.prototype.slice.apply(arguments)))
+}
+
+FLOAT._type = FLOAT
+FLOAT._typeName = 'FLOAT'
+INTEGER._type = INTEGER
+INTEGER._typeName = 'INTEGER'
+BIGINT._type = BIGINT
+BIGINT._typeName = 'BIGINT'
+STRING._type = STRING
+STRING._typeName = 'VARCHAR'
+BLOB._type = BLOB
+BLOB._typeName = 'BLOB'
+
+BLOB.toString = STRING.toString = INTEGER.toString = FLOAT.toString = BIGINT.toString = function() {
+  return new this._type().toString()
+}
+
+BLOB.prototype = {
+
+  construct: function(RealType, length) {
+    if (this instanceof RealType) {
+      this._typeName = RealType._typeName
+      if (typeof length === 'string') {
+        this._length = length
+      } else {
+        this._length = ''
+      }
+    } else {
+      return new RealType(length)
+    }
+  },
+
+  get type() {
+    return this.toString()
+  },
+
+  toString: function() {
+    switch (this._length.toLowerCase()) {
+    case 'tiny':
+      return 'TINYBLOB'
+    case 'medium':
+      return 'MEDIUMBLOB'
+    case 'long':
+      return 'LONGBLOB'
+    default:
+      return this._typeName
+    }
+  }
+}
 
 FLOAT.prototype = BIGINT.prototype = INTEGER.prototype = {
 
   construct: function(RealType, length, decimals, unsigned, zerofill) {
     if (this instanceof RealType) {
-      this._typeName = RealType._typeName;
-      this._unsigned = !!unsigned;
-      this._zerofill = !!zerofill;
+      this._typeName = RealType._typeName
+      this._unsigned = !!unsigned
+      this._zerofill = !!zerofill
       if (typeof length === 'number') {
-        this._length = length;
+        this._length = length
       }
       if (typeof decimals === 'number') {
-        this._decimals = decimals;
+        this._decimals = decimals
       }
     } else {
-      return new RealType(length, decimals, unsigned, zerofill);
+      return new RealType(length, decimals, unsigned, zerofill)
     }
   },
 
   get type() {
-    return this.toString();
+    return this.toString()
   },
 
   get UNSIGNED() {
-    this._unsigned = true;
-    return this;
+    this._unsigned = true
+    return this
   },
 
   get ZEROFILL() {
-    this._zerofill = true;
-    return this;
+    this._zerofill = true
+    return this
   },
 
   toString: function() {
-    var result = this._typeName;
+    var result = this._typeName
     if (this._length) {
-      result += '(' + this._length;
+      result += '(' + this._length
       if (typeof this._decimals === 'number') {
-        result += ',' + this._decimals;
+        result += ',' + this._decimals
       }
-      result += ')';
+      result += ')'
     }
     if (this._unsigned) {
-      result += ' UNSIGNED';
+      result += ' UNSIGNED'
     }
     if (this._zerofill) {
-      result += ' ZEROFILL';
+      result += ' ZEROFILL'
     }
-    return result;
+    return result
   }
-};
+}
 
 var unsignedDesc = {
   get: function() {
-    return new this._type(undefined, undefined, true);
+    return new this._type(undefined, undefined, true)
   }
-};
+}
 
 var zerofillDesc = {
   get: function() {
-    return new this._type(undefined, undefined, undefined, true);
+    return new this._type(undefined, undefined, undefined, true)
   }
-};
+}
 
 var typeDesc = {
   get: function() {
-    return new this._type().toString();
+    return new this._type().toString()
   }
-};
+}
 
-Object.defineProperty(STRING,  'type', typeDesc);
-Object.defineProperty(INTEGER, 'type', typeDesc);
-Object.defineProperty(BIGINT,  'type', typeDesc);
-Object.defineProperty(FLOAT,   'type', typeDesc);
+Object.defineProperty(STRING,  'type', typeDesc)
+Object.defineProperty(INTEGER, 'type', typeDesc)
+Object.defineProperty(BIGINT,  'type', typeDesc)
+Object.defineProperty(FLOAT,   'type', typeDesc)
+Object.defineProperty(BLOB,    'type', typeDesc)
 
-Object.defineProperty(INTEGER, 'UNSIGNED', unsignedDesc);
-Object.defineProperty(BIGINT,  'UNSIGNED', unsignedDesc);
-Object.defineProperty(FLOAT,   'UNSIGNED', unsignedDesc);
+Object.defineProperty(INTEGER, 'UNSIGNED', unsignedDesc)
+Object.defineProperty(BIGINT,  'UNSIGNED', unsignedDesc)
+Object.defineProperty(FLOAT,   'UNSIGNED', unsignedDesc)
 
-Object.defineProperty(INTEGER, 'ZEROFILL', zerofillDesc);
-Object.defineProperty(BIGINT,  'ZEROFILL', zerofillDesc);
-Object.defineProperty(FLOAT,   'ZEROFILL', zerofillDesc);
+Object.defineProperty(INTEGER, 'ZEROFILL', zerofillDesc)
+Object.defineProperty(BIGINT,  'ZEROFILL', zerofillDesc)
+Object.defineProperty(FLOAT,   'ZEROFILL', zerofillDesc)
 
 module.exports = {
   STRING: STRING,
@@ -147,6 +187,7 @@ module.exports = {
   BOOLEAN: 'TINYINT(1)',
   FLOAT: FLOAT,
   NOW: 'NOW',
+  BLOB: BLOB,
 
   get ENUM() {
     var result = function() {

lib/dialects/postgres/query-generator.js

@@ -795,6 +795,10 @@ module.exports = (function() {
         dataType = dataType.replace(/NOT NULL/, '')
       }
 
+      if (dataType.lastIndexOf('BLOB') !== -1) {
+        dataType = 'bytea'
+      }
+
       if (dataType.match(/^ENUM\(/)) {
         dataType = dataType.replace(/^ENUM\(.+\)/, this.pgEscapeAndQuote("enum_" + tableName + "_" + attr))
       }

lib/dialects/sqlite/query.js

@@ -29,7 +29,7 @@ module.exports = (function() {
       this.options.logging('Executing: ' + this.sql)
     }
 
-    var columnTypes = {};
+    var columnTypes = {}
     this.database.serialize(function() {
       var executeSql = function() {
         self.database[getDatabaseMethod.call(self)](self.sql, function(err, results) {
@@ -48,16 +48,16 @@ module.exports = (function() {
           self.database.all("PRAGMA table_info(" + tableName + ")", function(err, results) {
             if (!err) {
               for (var i=0, l=results.length; i<l; i++) {
-                columnTypes[results[i].name] = results[i].type;
+                columnTypes[results[i].name] = results[i].type
               }
             }
-            executeSql();
+            executeSql()
           });
         } else {
-          executeSql();
+          executeSql()
         }
       } else {
-        executeSql();
+        executeSql()
       }
     })
 
@@ -85,15 +85,18 @@ module.exports = (function() {
     if (this.sql.indexOf('sqlite_master') !== -1) {
       result = results.map(function(resultSet) { return resultSet.name })
     } else if (this.send('isSelectQuery')) {
-      // we need to convert the timestamps into actual date objects
-
       if(!this.options.raw) {
         results = results.map(function(result) {
           for (var name in result) {
-            if (result.hasOwnProperty(name) && (metaData.columnTypes[name] === 'DATETIME')) {
-              var val = result[name];
-              if(val !== null) {
-                result[name] = new Date(val+'Z'); // Z means UTC
+            if (result.hasOwnProperty(name) && metaData.columnTypes[name]) {
+              if (metaData.columnTypes[name] === 'DATETIME') {
+                // we need to convert the timestamps into actual date objects
+                var val = result[name]
+                if (val !== null) {
+                  result[name] = new Date(val+'Z') // Z means UTC
+                }
+              } else if (metaData.columnTypes[name].lastIndexOf('BLOB') !== -1) {
+                result[name] = new Buffer(result[name])
               }
             }
           }

lib/sql-string.js

@@ -41,7 +41,7 @@ SqlString.escape = function(val, stringifyObjects, timeZone, dialect, field) {
   }
 
   if (Buffer.isBuffer(val)) {
-    return SqlString.bufferToString(val);
+    return SqlString.bufferToString(val, dialect);
   }
 
   if (Array.isArray(val)) {
@@ -137,7 +137,7 @@ SqlString.dateToString = function(date, timeZone, dialect) {
   return moment(dt).format("YYYY-MM-DD HH:mm:ss");
 };
 
-SqlString.bufferToString = function(buffer) {
+SqlString.bufferToString = function(buffer, dialect) {
   var hex = '';
   try {
     hex = buffer.toString('hex');
@@ -149,6 +149,10 @@ SqlString.bufferToString = function(buffer) {
     }
   }
 
+  if (dialect === 'postgres') {
+    // bytea hex format http://www.postgresql.org/docs/current/static/datatype-binary.html
+    return "E'\\\\x" + hex+ "'";
+  }
   return "X'" + hex+ "'";
 };
 

test/dao-factory.test.js

@@ -2898,4 +2898,64 @@ describe(Support.getTestDialectTeaser("DAOFactory"), function () {
       })
     })
   })
+
+  describe("blob", function() {
+    beforeEach(function(done) {
+      this.BlobUser = this.sequelize.define("blobUser", {
+        data: Sequelize.BLOB
+      })
+
+      this.BlobUser.sync({ force: true }).success(function() {
+        done()
+      })
+    })
+
+    describe("buffers", function () {
+      it("should be able to take a buffer as parameter to a BLOB field", function (done) {
+        this.BlobUser.create({
+          data: new Buffer('Sequelize')
+        }).success(function (user) {
+          expect(user).to.be.ok
+          done()
+        })
+      })
+
+      it("should return a buffer when fetching a blob", function (done) {
+        var self = this
+        this.BlobUser.create({
+          data: new Buffer('Sequelize')
+        }).success(function (user) {
+          self.BlobUser.find(user.id).success(function (user) {
+            expect(user.data).to.be.an.instanceOf(Buffer)
+            expect(user.data.toString()).to.have.string('Sequelize')
+            done()
+          })
+        })
+      })
+    })
+
+    describe("strings", function () {
+      it("should be able to take a string as parameter to a BLOB field", function (done) {
+        this.BlobUser.create({
+          data: 'Sequelize'
+        }).success(function (user) {
+          expect(user).to.be.ok
+          done()
+        })
+      })
+
+      it("should return a buffer when fetching a BLOB, even when the BLOB was inserted as a string", function (done) {
+        var self = this
+        this.BlobUser.create({
+          data: 'Sequelize'
+        }).success(function (user) {
+          self.BlobUser.find(user.id).success(function (user) {
+            expect(user.data).to.be.an.instanceOf(Buffer)
+            expect(user.data.toString()).to.have.string('Sequelize')
+            done()
+          })
+        })
+      })
+    })
+  })
 })

test/data-types.test.js

@@ -27,6 +27,11 @@ describe(Support.getTestDialectTeaser('DataTypes'), function() {
     [Sequelize.NOW, 'NOW', 'NOW'],
     [Sequelize.BOOLEAN, 'BOOLEAN', 'TINYINT(1)'],
 
+    [Sequelize.BLOB, 'BLOB', 'BLOB'],
+    [Sequelize.BLOB('tiny'), 'BLOB(\'tiny\')', 'TINYBLOB'],
+    [Sequelize.BLOB('medium'), 'BLOB(\'medium\')', 'MEDIUMBLOB'],
+    [Sequelize.BLOB('long'), 'BLOB(\'long\')', 'LONGBLOB'],
+
     [Sequelize.INTEGER, 'INTEGER', 'INTEGER'],
     [Sequelize.INTEGER.UNSIGNED, 'INTEGER.UNSIGNED', 'INTEGER UNSIGNED'],
     [Sequelize.INTEGER(11), 'INTEGER(11)','INTEGER(11)'],

test/mysql/query-generator.test.js

@@ -85,6 +85,14 @@ if (dialect.match(/^mysql/)) {
           expectation: "CREATE TABLE IF NOT EXISTS `myTable` (`title` INTEGER) COMMENT 'I\\'m a comment!' ENGINE=InnoDB;"
         },
         {
+          arguments: ['myTable', {data: "BLOB"}],
+          expectation: "CREATE TABLE IF NOT EXISTS `myTable` (`data` BLOB) ENGINE=InnoDB;"
+        },
+        {
+          arguments: ['myTable', {data: "LONGBLOB"}],
+          expectation: "CREATE TABLE IF NOT EXISTS `myTable` (`data` LONGBLOB) ENGINE=InnoDB;"
+        },
+        {
           arguments: ['myTable', {title: 'VARCHAR(255)', name: 'VARCHAR(255)'}, {engine: 'MyISAM'}],
           expectation: "CREATE TABLE IF NOT EXISTS `myTable` (`title` VARCHAR(255), `name` VARCHAR(255)) ENGINE=MyISAM;"
         },
@@ -220,6 +228,9 @@ if (dialect.match(/^mysql/)) {
           arguments: ['myTable', {name: 'foo', foo: 1}],
           expectation: "INSERT INTO `myTable` (`name`,`foo`) VALUES ('foo',1);"
         }, {
+          arguments: ['myTable', {data: new Buffer('Sequelize') }],
+          expectation: "INSERT INTO `myTable` (`data`) VALUES (X'53657175656c697a65');"
+        }, {
           arguments: ['myTable', {name: 'foo', foo: 1, nullValue: null}],
           expectation: "INSERT INTO `myTable` (`name`,`foo`,`nullValue`) VALUES ('foo',1,NULL);"
         }, {

test/postgres/query-generator.test.js

@@ -126,6 +126,14 @@ if (dialect.match(/^postgres/)) {
           expectation: "CREATE TABLE IF NOT EXISTS \"myTable\" (\"title\" INTEGER); COMMENT ON TABLE \"myTable\" IS 'I''m a comment!';",
         },
         {
+          arguments: ['myTable', {data: "BLOB"}],
+          expectation: "CREATE TABLE IF NOT EXISTS \"myTable\" (\"data\" bytea);"
+        },
+        {
+          arguments: ['myTable', {data: "LONGBLOB"}],
+          expectation: "CREATE TABLE IF NOT EXISTS \"myTable\" (\"data\" bytea);"
+        },
+        {
           arguments: ['mySchema.myTable', {title: 'VARCHAR(255)', name: 'VARCHAR(255)'}],
           expectation: "CREATE TABLE IF NOT EXISTS \"mySchema\".\"myTable\" (\"title\" VARCHAR(255), \"name\" VARCHAR(255));"
         },
@@ -350,6 +358,9 @@ if (dialect.match(/^postgres/)) {
           arguments: ['myTable', {name: 'foo', birthday: moment("2011-03-27 10:01:55 +0000", "YYYY-MM-DD HH:mm:ss Z").toDate()}],
           expectation: "INSERT INTO \"myTable\" (\"name\",\"birthday\") VALUES ('foo','2011-03-27 10:01:55.000 +00:00') RETURNING *;"
         }, {
+          arguments: ['myTable', {data: new Buffer('Sequelize') }],
+          expectation: "INSERT INTO \"myTable\" (\"data\") VALUES (E'\\\\x53657175656c697a65') RETURNING *;"
+        }, {
           arguments: ['myTable', {name: 'foo', foo: 1}],
           expectation: "INSERT INTO \"myTable\" (\"name\",\"foo\") VALUES ('foo',1) RETURNING *;"
         }, {

test/sqlite/query-generator.test.js

@@ -79,6 +79,14 @@ if (dialect === 'sqlite') {
 
       createTableQuery: [
         {
+          arguments: ['myTable', {data: "BLOB"}],
+          expectation: "CREATE TABLE IF NOT EXISTS `myTable` (`data` BLOB);"
+        },
+        {
+          arguments: ['myTable', {data: "LONGBLOB"}],
+          expectation: "CREATE TABLE IF NOT EXISTS `myTable` (`data` LONGBLOB);"
+        },
+        {
           arguments: ['myTable', {title: 'VARCHAR(255)', name: 'VARCHAR(255)'}],
           expectation: "CREATE TABLE IF NOT EXISTS `myTable` (`title` VARCHAR(255), `name` VARCHAR(255));"
         },
@@ -104,6 +112,9 @@ if (dialect === 'sqlite') {
           arguments: ['myTable', { name: "'bar'" }],
           expectation: "INSERT INTO `myTable` (`name`) VALUES ('''bar''');"
         }, {
+          arguments: ['myTable', {data: new Buffer('Sequelize') }],
+          expectation: "INSERT INTO `myTable` (`data`) VALUES (X'53657175656c697a65');"
+        }, {
           arguments: ['myTable', { name: "bar", value: null }],
           expectation: "INSERT INTO `myTable` (`name`,`value`) VALUES ('bar',NULL);"
         }, {