SNOW-728803: Do not replace sqlText if it is specified by the user

lib/connection/statement.js

@@ -420,6 +420,12 @@ function createContextPreExec(
     {
       statementContext.requestId = statementOptions.requestId;
     }
+
+    // SNOW-728803: In QA mode, set resubmitRequest to true to test that sqlText
+    // is not overwritten if a sqlText is already specified by the user
+    if (statementOptions.requestId === 'SNOW-728803-requestId') {
+      statementContext.resubmitRequest = true;
+    }
   }
 
   return statementContext;
@@ -1310,12 +1316,9 @@ function sendRequestPreExec(statementContext, onResultAvailable)
   {
     disableOfflineChunks: false,
   };
-  if (!statementContext.resubmitRequest)
-  {
-    json.sqlText = statementContext.sqlText;
-  }
-  else
-  {
+  json.sqlText = statementContext.sqlText;
+
+  if (statementContext.resubmitRequest && !json.sqlText) {
     json.sqlText = `SELECT 'Error retrieving query results for request id: ${statementContext.requestId}, `
        + `please use RESULT_SCAN instead' AS ErrorMessage;`;
   }

test/unit/mock/mock_http_client.js

@@ -700,6 +700,114 @@ function buildRequestOutputMappings(clientInfo)
             }
         }
     },
+    {
+      request:
+        {
+          method: 'POST',
+          url: 'http://fakeaccount.snowflakecomputing.com/queries/v1/query-request?requestId=',
+          headers:
+            {
+              'Accept': 'application/snowflake',
+              'Authorization': 'Snowflake Token="SESSION_TOKEN"',
+              'Content-Type': 'application/json'
+            },
+          json:
+            {
+              disableOfflineChunks: false,
+              sqlText: 'select 1;',
+              queryContextDTO: { entries: [] }
+            }
+        },
+      output:
+        {
+          err: null,
+          response:
+            {
+              statusCode: 401,
+              statusMessage: 'Unauthorized',
+              body:
+                {
+                  'data' : null,
+                  'code': '390103',
+                  'message': 'Session token not found in the request data.',
+                  'success': false,
+                }
+            }
+        }
+    },
+    {
+      request:
+        {
+          method: 'POST',
+          url: 'http://fakeaccount.snowflakecomputing.com/queries/v1/query-request?requestId=SNOW-728803-requestId',
+          headers:
+            {
+              'Accept': 'application/snowflake',
+              'Authorization': 'Snowflake Token="SESSION_TOKEN"',
+              'Content-Type': 'application/json'
+            },
+          json:
+            {
+              disableOfflineChunks: false,
+              sqlText: 'SELECT \'Error retrieving query results for request id: SNOW-728803-requestId, please use RESULT_SCAN instead\' AS ErrorMessage;',
+              queryContextDTO: { entries: [] }
+            }
+        },
+      output:
+        {
+          err: null,
+          response:
+            {
+              body:
+                {
+                  'message': 'The specified sqlText should not be overwritten when resubmitting the request',
+                  'success': false
+                }
+            }
+        }
+    },
+    {
+      request:
+        {
+          method: 'POST',
+          url: 'http://fakeaccount.snowflakecomputing.com/queries/v1/query-request?requestId=SNOW-728803-requestId',
+          headers:
+            {
+              'Accept': 'application/snowflake',
+              'Authorization': 'Snowflake Token="SESSION_TOKEN"',
+              'Content-Type': 'application/json'
+            },
+          json:
+            {
+              disableOfflineChunks: false,
+              sqlText: 'select 1;',
+              queryContextDTO: { entries: [] }
+            }
+        },
+      output:
+        {
+          err: null,
+          response:
+            {
+              statusCode: 200,
+              statusMessage: 'OK',
+              body:
+                {
+                  'data':
+                    {
+                      'parameters': [],
+                      'rowtype': [],
+                      'rowset': [['1']],
+                      'total': 1,
+                      'returned': 1
+                    },
+                  'message': null,
+                  'code': null,
+                  'success': true
+                }
+            }
+        }
+    },
     {
       request:
         {

test/unit/snowflake_test.js

@@ -936,6 +936,71 @@ describe('connection.execute() statement failure', function ()
   });
 });
 
+describe('connection.execute() with requestId', function () {
+  const connection = snowflake.createConnection(connectionOptions);
+  const sqlText = 'select 1;';
+  const requestId = 'SNOW-728803-requestId';
+
+  it('keep original sqlText when resubmitting requests', function (done) {
+    let statement;
+
+    async.series(
+      [
+        function (callback) {
+          connection.connect(function (err, conn) {
+            assert.ok(!err, 'there should be no error');
+            assert.strictEqual(conn, connection,
+              'the connect() callback should be invoked with the statement');
+
+            callback();
+          });
+        },
+        function (callback) {
+          // 1st request fails with an error
+          statement = connection.execute(
+            {
+              sqlText: sqlText,
+              complete: function (err, stmt) {
+                assert.ok(err, 'there should be an error');
+                assert.strictEqual(stmt, statement,
+                  'the execute() callback should be invoked with the statement');
+
+                callback();
+              }
+            });
+        },
+        function (callback) {
+          // 2nd request with sqlText and requestId specified
+          statement = connection.execute(
+            {
+              sqlText: sqlText,
+              requestId: requestId,
+              complete: function (err, stmt) {
+                // if there's an error, fail the test with the error
+                if (err) {
+                  done(err);
+                }
+
+                assert.ok(!err, 'there should be no error');
+                assert.strictEqual(stmt, statement,
+                  'the execute() callback should be invoked with the statement');
+
+                callback();
+              }
+            });
+
+          // the sql text and request id should be the same as what was passed
+          // in
+          assert.strictEqual(statement.getSqlText(), sqlText);
+          assert.strictEqual(statement.getRequestId(), requestId);
+        }
+      ],
+      function () {
+        done();
+      });
+  });
+});
+
 describe('too many concurrent requests', function ()
 {
   it('too many concurrent requests per user', function (done)