fix: throw timeout error when using jobs.query

src/bigquery.ts

@@ -362,17 +362,17 @@
   private _universeDomain: string;
   private _enableQueryPreview: boolean;
 
   createQueryStream(options?: Query | string): ResourceStream<RowMetadata> {
     // placeholder body, overwritten in constructor
     return new ResourceStream<RowMetadata>({}, () => {});
   }
 
   getDatasetsStream(options?: GetDatasetsOptions): ResourceStream<Dataset> {
     // placeholder body, overwritten in constructor
     return new ResourceStream<Dataset>({}, () => {});
   }
 
   getJobsStream(options?: GetJobsOptions): ResourceStream<Job> {
     // placeholder body, overwritten in constructor
     return new ResourceStream<Job>({}, () => {});
   }
@@ -1569,7 +1569,7 @@
     const parameterMode = is.array(params) ? 'positional' : 'named';
     const queryParameters: bigquery.IQueryParameter[] = [];
     if (parameterMode === 'named') {
       const namedParams = params as {[param: string]: any};
       for (const namedParameter of Object.getOwnPropertyNames(namedParams)) {
         const value = namedParams[namedParameter];
         let queryParameter;
@@ -2206,13 +2206,13 @@
     this.runJobsQuery(queryReq, (err, job, res) => {
       this.trace_('[runJobsQuery callback]: ', query, err, job, res);
       if (err) {
-        (callback as SimpleQueryRowsCallback)(err, null, res);
+        (callback as SimpleQueryRowsCallback)(err, null, job);
         return;
       }
 
       options = extend({job}, queryOpts, options);
       if (res && res.jobComplete) {
         let rows: any = [];
         if (res.schema && res.rows) {
           rows = BigQuery.mergeSchemaWithRows_(res.schema, res.rows, {
             wrapIntegers: options.wrapIntegers || false,
@@ -2232,6 +2232,14 @@
         job!.getQueryResults(options, callback as QueryRowsCallback);
         return;
       }
+      // If timeout override was provided, return error.
+      if (queryReq.timeoutMs) {
+        const err = new Error(
+          `The query did not complete before ${queryReq.timeoutMs}ms`
+        );
+        (callback as SimpleQueryRowsCallback)(err, null, job);
+        return;
+      }
       delete options.timeoutMs;
       this.trace_('[runJobsQuery] job not complete');
       job!.getQueryResults(options, callback as QueryRowsCallback);

system-test/bigquery.ts

@@ -369,6 +369,43 @@ describe('BigQuery', () => {
     assert.strictEqual(res.totalRows, '100');
   });
 
+  describe('Query timeout', () => {
+    let longRunningQuery = '';
+
+    beforeEach(() => {
+      const tableId = generateName('table');
+      longRunningQuery = `CREATE TABLE ${dataset.projectId}.${dataset.id}.${tableId} AS SELECT num FROM UNNEST(GENERATE_ARRAY(1,1000000)) as num`;
+    });
+
+    it('should throw a timeout error with jobs.query', async () => {
+      const qOpts: QueryOptions = {
+        timeoutMs: 1000,
+      };
+      let foundError: Error | null = null;
+      try {
+        await bigquery.query(longRunningQuery, qOpts);
+      } catch (error: unknown) {
+        foundError = error as Error;
+      }
+      assert.notEqual(foundError, null);
+    });
+
+    it('should throw a timeout error without jobs.query', async () => {
+      const jobId = generateName('job');
+      const qOpts: QueryOptions = {
+        job: bigquery.job(jobId),
+        timeoutMs: 1000,
+      };
+      let foundError: Error | null = null;
+      try {
+        await bigquery.query(longRunningQuery, qOpts);
+      } catch (error: unknown) {
+        foundError = error as Error;
+      }
+      assert.notEqual(foundError, null);
+    });
+  });
+
   it('should allow querying in series', done => {
     bigquery.query(
       query,

test/bigquery.ts

@@ -3108,7 +3108,7 @@ describe('BigQuery', () => {
       const error = new Error('err');
 
       bq.runJobsQuery = (query: {}, callback: Function) => {
-        callback(error, null, FAKE_RESPONSE);
+        callback(error, FAKE_RESPONSE, {});
       };
 
       bq.query(QUERY_STRING, (err: Error, rows: {}, resp: {}) => {
@@ -3119,6 +3119,31 @@ describe('BigQuery', () => {
       });
     });
 
+    it('should return throw error when jobs.query times out', done => {
+      const fakeJob = {};
+
+      bq.runJobsQuery = (query: {}, callback: Function) => {
+        callback(null, fakeJob, {
+          queryId: uuid.v1(),
+          jobComplete: false,
+        });
+      };
+
+      bq.query(
+        QUERY_STRING,
+        {timeoutMs: 1000},
+        (err: Error, rows: {}, resp: {}) => {
+          assert.strictEqual(
+            err.message,
+            'The query did not complete before 1000ms'
+          );
+          assert.strictEqual(rows, null);
+          assert.strictEqual(resp, fakeJob);
+          done();
+        }
+      );
+    });
+
     it('should exit early if dryRun is set', done => {
       const options = {
         query: QUERY_STRING,