fix(instance/decrement): doesn't work with negative value (#8267)

lib/dialects/abstract/query-generator.js

@@ -403,7 +403,7 @@ const QueryGenerator = {
 
 
     for (const key in attrValueHash) {
     for (const key in attrValueHash) {
       const value = attrValueHash[key];
       const value = attrValueHash[key];
-      values.push(this.quoteIdentifier(key) + '=' + this.quoteIdentifier(key) + operator + this.escape(value));
+      values.push(this.quoteIdentifier(key) + '=' + this.quoteIdentifier(key) + operator + ' ' + this.escape(value));
     }
     }
 
 
     attributes = attributes || {};
     attributes = attributes || {};

test/integration/instance.test.js

@@ -398,6 +398,22 @@ describe(Support.getTestDialectTeaser('Instance'), () => {
       });
       });
     });
     });
 
 
+    it('with negative value', function () {
+      const self = this;
+      return this.User.findById(1).then(user1 => {
+        return self.sequelize.Promise.all([
+          user1.decrement('aNumber', { by: -2 }),
+          user1.decrement(['aNumber', 'bNumber'], { by: -2 }),
+          user1.decrement({ 'aNumber': -1, 'bNumber': -2 }),
+        ]).then(() => {
+          return self.User.findById(1).then(user3 => {
+            expect(user3.aNumber).to.be.equal(+5);
+            expect(user3.bNumber).to.be.equal(+4);
+          });
+        });
+      });
+    });
+
     it('with timestamps set to true', function() {
     it('with timestamps set to true', function() {
       const User = this.sequelize.define('IncrementUser', {
       const User = this.sequelize.define('IncrementUser', {
         aNumber: DataTypes.INTEGER
         aNumber: DataTypes.INTEGER

test/unit/dialects/mssql/query-generator.test.js

@@ -175,22 +175,27 @@ if (current.dialect.name === 'mssql') {
       [{
       [{
         title:'Should use the plus operator',
         title:'Should use the plus operator',
         arguments: ['+', 'myTable', { foo: 'bar' }, {}, {}],
         arguments: ['+', 'myTable', { foo: 'bar' }, {}, {}],
-        expectation: 'UPDATE myTable SET foo=foo+\'bar\' '
+        expectation: 'UPDATE myTable SET foo=foo+ \'bar\' '
       },
       },
       {
       {
         title:'Should use the plus operator with where clause',
         title:'Should use the plus operator with where clause',
         arguments: ['+', 'myTable', { foo: 'bar' }, { bar: 'biz'}, {}],
         arguments: ['+', 'myTable', { foo: 'bar' }, { bar: 'biz'}, {}],
-        expectation: 'UPDATE myTable SET foo=foo+\'bar\' WHERE bar = \'biz\''
+        expectation: 'UPDATE myTable SET foo=foo+ \'bar\' WHERE bar = \'biz\''
       },
       },
       {
       {
         title:'Should use the minus operator',
         title:'Should use the minus operator',
         arguments: ['-', 'myTable', { foo: 'bar' }, {}, {}],
         arguments: ['-', 'myTable', { foo: 'bar' }, {}, {}],
-        expectation: 'UPDATE myTable SET foo=foo-\'bar\' '
+        expectation: 'UPDATE myTable SET foo=foo- \'bar\' '
+      },
+      {
+        title:'Should use the minus operator with negative value',
+        arguments: ['-', 'myTable', { foo: -1 }, {}, {}],
+        expectation: 'UPDATE myTable SET foo=foo- -1 '
       },
       },
       {
       {
         title:'Should use the minus operator with where clause',
         title:'Should use the minus operator with where clause',
         arguments: ['-', 'myTable', { foo: 'bar' }, { bar: 'biz'}, {}],
         arguments: ['-', 'myTable', { foo: 'bar' }, { bar: 'biz'}, {}],
-        expectation: 'UPDATE myTable SET foo=foo-\'bar\' WHERE bar = \'biz\''
+        expectation: 'UPDATE myTable SET foo=foo- \'bar\' WHERE bar = \'biz\''
       }].forEach(test => {
       }].forEach(test => {
         it(test.title, () => {
         it(test.title, () => {
           expectsql(QueryGenerator.arithmeticQuery.call(QueryGenerator, test.arguments), {
           expectsql(QueryGenerator.arithmeticQuery.call(QueryGenerator, test.arguments), {

test/unit/dialects/mysql/query-generator.test.js

@@ -14,22 +14,27 @@ if (dialect === 'mysql') {
         {
         {
           title:'Should use the plus operator',
           title:'Should use the plus operator',
           arguments: ['+', 'myTable', { foo: 'bar' }, {}, {}],
           arguments: ['+', 'myTable', { foo: 'bar' }, {}, {}],
-          expectation: 'UPDATE `myTable` SET `foo`=`foo`+\'bar\' '
+          expectation: 'UPDATE `myTable` SET `foo`=`foo`+ \'bar\' '
         },
         },
         {
         {
           title:'Should use the plus operator with where clause',
           title:'Should use the plus operator with where clause',
           arguments: ['+', 'myTable', { foo: 'bar' }, { bar: 'biz'}, {}],
           arguments: ['+', 'myTable', { foo: 'bar' }, { bar: 'biz'}, {}],
-          expectation: 'UPDATE `myTable` SET `foo`=`foo`+\'bar\' WHERE `bar` = \'biz\''
+          expectation: 'UPDATE `myTable` SET `foo`=`foo`+ \'bar\' WHERE `bar` = \'biz\''
         },
         },
         {
         {
           title:'Should use the minus operator',
           title:'Should use the minus operator',
           arguments: ['-', 'myTable', { foo: 'bar' }, {}, {}],
           arguments: ['-', 'myTable', { foo: 'bar' }, {}, {}],
-          expectation: 'UPDATE `myTable` SET `foo`=`foo`-\'bar\' '
+          expectation: 'UPDATE `myTable` SET `foo`=`foo`- \'bar\' '
+        },
+        {
+          title:'Should use the minus operator with negative value',
+          arguments: ['-', 'myTable', { foo: -1 }, {}, {}],
+          expectation: 'UPDATE `myTable` SET `foo`=`foo`- -1 '
         },
         },
         {
         {
           title:'Should use the minus operator with where clause',
           title:'Should use the minus operator with where clause',
           arguments: ['-', 'myTable', { foo: 'bar' }, { bar: 'biz'}, {}],
           arguments: ['-', 'myTable', { foo: 'bar' }, { bar: 'biz'}, {}],
-          expectation: 'UPDATE `myTable` SET `foo`=`foo`-\'bar\' WHERE `bar` = \'biz\''
+          expectation: 'UPDATE `myTable` SET `foo`=`foo`- \'bar\' WHERE `bar` = \'biz\''
         }
         }
       ],
       ],
       attributesToSQL: [
       attributesToSQL: [

test/unit/dialects/postgres/query-generator.test.js

@@ -17,22 +17,27 @@ if (dialect.match(/^postgres/)) {
         {
         {
           title:'Should use the plus operator',
           title:'Should use the plus operator',
           arguments: ['+', 'myTable', { foo: 'bar' }, {}, {}],
           arguments: ['+', 'myTable', { foo: 'bar' }, {}, {}],
-          expectation: 'UPDATE "myTable" SET "foo"="foo"+\'bar\'  RETURNING *'
+          expectation: 'UPDATE "myTable" SET "foo"="foo"+ \'bar\'  RETURNING *'
         },
         },
         {
         {
           title:'Should use the plus operator with where clause',
           title:'Should use the plus operator with where clause',
           arguments: ['+', 'myTable', { foo: 'bar' }, { bar: 'biz'}, {}],
           arguments: ['+', 'myTable', { foo: 'bar' }, { bar: 'biz'}, {}],
-          expectation: 'UPDATE "myTable" SET "foo"="foo"+\'bar\' WHERE "bar" = \'biz\' RETURNING *'
+          expectation: 'UPDATE "myTable" SET "foo"="foo"+ \'bar\' WHERE "bar" = \'biz\' RETURNING *'
         },
         },
         {
         {
           title:'Should use the minus operator',
           title:'Should use the minus operator',
           arguments: ['-', 'myTable', { foo: 'bar' }, {}, {}],
           arguments: ['-', 'myTable', { foo: 'bar' }, {}, {}],
-          expectation: 'UPDATE "myTable" SET "foo"="foo"-\'bar\'  RETURNING *'
+          expectation: 'UPDATE "myTable" SET "foo"="foo"- \'bar\'  RETURNING *'
+        },
+        {
+          title:'Should use the minus operator with negative value',
+          arguments: ['-', 'myTable', { foo: -1 }, {}, {}],
+          expectation: 'UPDATE "myTable" SET "foo"="foo"- -1  RETURNING *'
         },
         },
         {
         {
           title:'Should use the minus operator with where clause',
           title:'Should use the minus operator with where clause',
           arguments: ['-', 'myTable', { foo: 'bar' }, { bar: 'biz'}, {}],
           arguments: ['-', 'myTable', { foo: 'bar' }, { bar: 'biz'}, {}],
-          expectation: 'UPDATE "myTable" SET "foo"="foo"-\'bar\' WHERE "bar" = \'biz\' RETURNING *'
+          expectation: 'UPDATE "myTable" SET "foo"="foo"- \'bar\' WHERE "bar" = \'biz\' RETURNING *'
         }
         }
       ],
       ],
       attributesToSQL: [
       attributesToSQL: [

test/unit/dialects/sqlite/query-generator.test.js

@@ -23,22 +23,27 @@ if (dialect === 'sqlite') {
         {
         {
           title:'Should use the plus operator',
           title:'Should use the plus operator',
           arguments: ['+', 'myTable', { foo: 'bar' }, {}],
           arguments: ['+', 'myTable', { foo: 'bar' }, {}],
-          expectation: 'UPDATE `myTable` SET `foo`=`foo`+\'bar\' '
+          expectation: 'UPDATE `myTable` SET `foo`=`foo`+ \'bar\' '
         },
         },
         {
         {
           title:'Should use the plus operator with where clause',
           title:'Should use the plus operator with where clause',
           arguments: ['+', 'myTable', { foo: 'bar' }, { bar: 'biz'}],
           arguments: ['+', 'myTable', { foo: 'bar' }, { bar: 'biz'}],
-          expectation: 'UPDATE `myTable` SET `foo`=`foo`+\'bar\' WHERE `bar` = \'biz\''
+          expectation: 'UPDATE `myTable` SET `foo`=`foo`+ \'bar\' WHERE `bar` = \'biz\''
         },
         },
         {
         {
           title:'Should use the minus operator',
           title:'Should use the minus operator',
           arguments: ['-', 'myTable', { foo: 'bar' }],
           arguments: ['-', 'myTable', { foo: 'bar' }],
-          expectation: 'UPDATE `myTable` SET `foo`=`foo`-\'bar\' '
+          expectation: 'UPDATE `myTable` SET `foo`=`foo`- \'bar\' '
+        },
+        {
+          title:'Should use the minus operator with negative value',
+          arguments: ['-', 'myTable', { foo: -1 }],
+          expectation: 'UPDATE `myTable` SET `foo`=`foo`- -1 '
         },
         },
         {
         {
           title:'Should use the minus operator with where clause',
           title:'Should use the minus operator with where clause',
           arguments: ['-', 'myTable', { foo: 'bar' }, { bar: 'biz'}],
           arguments: ['-', 'myTable', { foo: 'bar' }, { bar: 'biz'}],
-          expectation: 'UPDATE `myTable` SET `foo`=`foo`-\'bar\' WHERE `bar` = \'biz\''
+          expectation: 'UPDATE `myTable` SET `foo`=`foo`- \'bar\' WHERE `bar` = \'biz\''
         }
         }
       ],
       ],
       attributesToSQL: [
       attributesToSQL: [