fix(sequelize/query): retry entire query (#8991)

lib/sequelize.js

@@ -163,7 +163,12 @@ class Sequelize {
       pool: {},
       quoteIdentifiers: true,
       hooks: {},
-      retry: {max: 5, match: ['SQLITE_BUSY: database is locked']},
+      retry: {
+        max: 5,
+        match: [
+          'SQLITE_BUSY: database is locked'
+        ]
+      },
       transactionType: Transaction.TYPES.DEFERRED,
       isolationLevel: null,
       databaseVersion: 0,
@@ -441,10 +446,13 @@ class Sequelize {
    */
 
   query(sql, options) {
+    options = _.assign({}, this.options.query, options);
+    const retryOptions = _.assignIn({}, this.options.retry, options.retry || {});
+
     let bindParameters;
 
-    return Promise.try(() => {
-      options = _.assign({}, this.options.query, options);
+    return retry(retryParameters => Promise.try(() => {
+      const isFirstTry = retryParameters.current === 1;
 
       if (options.instance && !options.model) {
         options.model = options.instance.constructor;
@@ -517,41 +525,47 @@ class Sequelize {
       }
 
       if (options.transaction && options.transaction.finished) {
-        const error = new Error(options.transaction.finished+' has been called on this transaction('+options.transaction.id+'), you can no longer use it. (The rejected query is attached as the \'sql\' property of this error)');
+        const error = new Error(`${options.transaction.finished} has been called on this transaction(${options.transaction.id}), you can no longer use it. (The rejected query is attached as the \'sql\' property of this error)`);
         error.sql = sql;
         return Promise.reject(error);
       }
 
-      if (this.test._trackRunningQueries) {
+      if (isFirstTry && this.test._trackRunningQueries) {
         this.test._runningQueries++;
       }
 
       //if dialect doesn't support search_path or dialect option
       //to prepend searchPath is not true delete the searchPath option
-      if (!this.dialect.supports.searchPath || !this.options.dialectOptions || !this.options.dialectOptions.prependSearchPath ||
-        options.supportsSearchPath === false) {
+      if (
+        !this.dialect.supports.searchPath ||
+        !this.options.dialectOptions ||
+        !this.options.dialectOptions.prependSearchPath ||
+        options.supportsSearchPath === false
+      ) {
         delete options.searchPath;
       } else if (!options.searchPath) {
         //if user wants to always prepend searchPath (dialectOptions.preprendSearchPath = true)
         //then set to DEFAULT if none is provided
         options.searchPath = 'DEFAULT';
       }
-      return options.transaction ? options.transaction.connection : this.connectionManager.getConnection(options);
+
+      return options.transaction
+        ? options.transaction.connection
+        : this.connectionManager.getConnection(options);
     }).then(connection => {
       const query = new this.dialect.Query(connection, this, options);
-      const retryOptions = _.extend(this.options.retry, options.retry || {});
 
-      return retry(() => query.run(sql, bindParameters), retryOptions)
+      return query.run(sql, bindParameters)
         .finally(() => {
-          if (!options.transaction) {
-            return this.connectionManager.releaseConnection(connection);
-          }
-        });
-    }).finally(() => {
           if (this.test._trackRunningQueries) {
             this.test._runningQueries--;
           }
+
+          if (!options.transaction) {
+            return this.connectionManager.releaseConnection(connection);
+          }
         });
+    }), retryOptions);
   }
 
   /**

test/unit/query.test.js

-'use strict';
-
-const chai = require('chai'),
-  sinon = require('sinon'),
-  expect = chai.expect,
-  Support = require(__dirname + '/support'),
-  Sequelize = Support.Sequelize,
-  Promise = Sequelize.Promise,
-  current = Support.sequelize;
-
-describe('sequelize.query', () => {
-  it('connection should be released only once when retry fails', () => {
-    const getConnectionStub = sinon.stub(current.connectionManager, 'getConnection').callsFake(() => {
-      return Promise.resolve({});
-    });
-    const releaseConnectionStub = sinon.stub(current.connectionManager, 'releaseConnection').callsFake(() => {
-      return Promise.resolve();
-    });
-    const queryStub = sinon.stub(current.dialect.Query.prototype, 'run').callsFake(() => {
-      return Promise.reject(new Error('wrong sql'));
-    });
-    return current.query('THIS IS A WRONG SQL', {
-      retry: {
-        max: 2,
-        // retry for all errors
-        match: null
-      }
-    })
-      .catch(() => {})
-      .finally(() => {
-        expect(releaseConnectionStub).have.been.calledOnce;
-        queryStub.restore();
-        getConnectionStub.restore();
-        releaseConnectionStub.restore();
-      });
-  });
-});