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

Sascha Depold
Commit 295d0c25 authored Aug 23, 2013 by Sascha Depold
Showing with 230 additions and 79 deletions
changelog.md
lib/data-types.js
lib/dialects/postgres/query-generator.js
lib/dialects/sqlite/query.js
lib/sql-string.js
test/dao-factory.test.js
test/data-types.test.js
test/mysql/query-generator.test.js
test/postgres/query-generator.test.js
test/sqlite/query-generator.test.js
--- a/changelog.md
+++ b/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

--- a/lib/data-types.js
+++ b/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;
+    this._binary = true
-    return this;
+    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)));
+  return FLOAT.prototype.construct.apply(this, [FLOAT].concat(Array.prototype.slice.apply(arguments)))
-};
+}
-FLOAT._type = FLOAT;
+var BLOB = function() {
-FLOAT._typeName = 'FLOAT';
+  return BLOB.prototype.construct.apply(this, [BLOB].concat(Array.prototype.slice.apply(arguments)))
-INTEGER._type = INTEGER;
+}
-INTEGER._typeName = 'INTEGER';
-BIGINT._type = BIGINT;
+FLOAT._type = FLOAT
-BIGINT._typeName = 'BIGINT';
+FLOAT._typeName = 'FLOAT'
-STRING._type = STRING;
+INTEGER._type = INTEGER
-STRING._typeName = 'VARCHAR';
+INTEGER._typeName = 'INTEGER'
+BIGINT._type = BIGINT
-STRING.toString = INTEGER.toString = FLOAT.toString = BIGINT.toString = function() {
+BIGINT._typeName = 'BIGINT'
-  return new this._type().toString();
+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._typeName = RealType._typeName
-      this._unsigned = !!unsigned;
+      this._unsigned = !!unsigned
-      this._zerofill = !!zerofill;
+      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;
+    this._unsigned = true
-    return this;
+    return this
  },
  get ZEROFILL() {
-    this._zerofill = true;
+    this._zerofill = true
-    return this;
+    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(STRING,  'type', typeDesc)
-Object.defineProperty(INTEGER, 'type', typeDesc);
+Object.defineProperty(INTEGER, 'type', typeDesc)
-Object.defineProperty(BIGINT,  'type', typeDesc);
+Object.defineProperty(BIGINT,  'type', typeDesc)
-Object.defineProperty(FLOAT,   'type', typeDesc);
+Object.defineProperty(FLOAT,   'type', typeDesc)
+Object.defineProperty(BLOB,    'type', typeDesc)
-Object.defineProperty(INTEGER, 'UNSIGNED', unsignedDesc);
+Object.defineProperty(INTEGER, 'UNSIGNED', unsignedDesc)
-Object.defineProperty(BIGINT,  'UNSIGNED', unsignedDesc);
+Object.defineProperty(BIGINT,  'UNSIGNED', unsignedDesc)
-Object.defineProperty(FLOAT,   'UNSIGNED', unsignedDesc);
+Object.defineProperty(FLOAT,   'UNSIGNED', unsignedDesc)
-Object.defineProperty(INTEGER, 'ZEROFILL', zerofillDesc);
+Object.defineProperty(INTEGER, 'ZEROFILL', zerofillDesc)
-Object.defineProperty(BIGINT,  'ZEROFILL', zerofillDesc);
+Object.defineProperty(BIGINT,  'ZEROFILL', zerofillDesc)
-Object.defineProperty(FLOAT,   '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() {

--- a/lib/dialects/postgres/query-generator.js
+++ b/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))
      }

--- a/lib/dialects/sqlite/query.js
+++ b/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')) {
+            if (result.hasOwnProperty(name) && metaData.columnTypes[name]) {
-              var val = result[name];
+              if (metaData.columnTypes[name] === 'DATETIME') {
-              if(val !== null) {
+                // we need to convert the timestamps into actual date objects
-                result[name] = new Date(val+'Z'); // Z means UTC
+                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])
              }
            }
          }

--- a/lib/sql-string.js
+++ b/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+ "'";
 };

--- a/test/dao-factory.test.js
+++ b/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()
+          })
+        })
+      })
+    })
+  })
 })
--- a/test/data-types.test.js
+++ b/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)'],

--- a/test/mysql/query-generator.test.js
+++ b/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);"
        }, {

--- a/test/postgres/query-generator.test.js
+++ b/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 *;"
        }, {

--- a/test/sqlite/query-generator.test.js
+++ b/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);"
        }, {