feat(mysql): support max_execution_time optimizer hint (#15341)

Co-authored-by: Rik Smale <13023439+WikiRik@users.noreply.github.com>
sequelize · May 4, 2023 · fc3d6aa · fc3d6aa
1 parent c3e1ae0
commit fc3d6aa
Show file tree

Hide file tree

Showing 9 changed files with 87 additions and 4 deletions.
diff --git a/packages/core/src/dialects/abstract/index.ts b/packages/core/src/dialects/abstract/index.ts
@@ -213,6 +213,9 @@ export type DialectSupports = {
   dropTable: {
     cascade: boolean,
   },
+  maxExecutionTimeHint: {
+    select: boolean,
+  },
   truncate: {
     cascade: boolean,
   },
@@ -338,6 +341,9 @@ export abstract class AbstractDialect {
     dropTable: {
       cascade: false,
     },
+    maxExecutionTimeHint: {
+      select: false,
+    },
     truncate: {
       cascade: false,
     },

diff --git a/packages/core/src/dialects/abstract/query-generator.js b/packages/core/src/dialects/abstract/query-generator.js
@@ -2172,10 +2172,24 @@ export class AbstractQueryGenerator extends AbstractQueryGeneratorTypeScript {
     throw new sequelizeError.QueryError(message.replace(/ +/g, ' '));
   }
 
+  _validateSelectOptions(options) {
+    if (options.maxExecutionTimeHintMs != null && !this.dialect.supports.maxExecutionTimeHint.select) {
+      throw new Error(`The maxExecutionTimeMs option is not supported by ${this.dialect.name}`);
+    }
+  }
+
+  _getBeforeSelectAttributesFragment(_options) {
+    return '';
+  }
+
   selectFromTableFragment(options, model, attributes, tables, mainTableAs) {
     this._throwOnEmptyAttributes(attributes, { modelName: model && model.name, as: mainTableAs });
 
-    let fragment = `SELECT ${attributes.join(', ')} FROM ${tables}`;
+    this._validateSelectOptions(options);
+
+    let fragment = 'SELECT';
+    fragment += this._getBeforeSelectAttributesFragment(options);
+    fragment += ` ${attributes.join(', ')} FROM ${tables}`;
 
     if (mainTableAs) {
       fragment += ` AS ${mainTableAs}`;

diff --git a/packages/core/src/dialects/mariadb/query-generator.js b/packages/core/src/dialects/mariadb/query-generator.js
@@ -12,6 +12,10 @@ export class MariaDbQueryGenerator extends MariaDbQueryGeneratorTypeScript {
     return ['MYSQL', 'INFORMATION_SCHEMA', 'PERFORMANCE_SCHEMA', 'mysql', 'information_schema', 'performance_schema'];
   }
 
+  _getBeforeSelectAttributesFragment(_options) {
+    return '';
+  }
+
   addColumnQuery(table, key, dataType, options = {}) {
     const ifNotExists = options.ifNotExists ? 'IF NOT EXISTS' : '';
 

diff --git a/packages/core/src/dialects/mssql/query-generator.js b/packages/core/src/dialects/mssql/query-generator.js
@@ -887,6 +887,11 @@ export class MsSqlQueryGenerator extends MsSqlQueryGeneratorTypeScript {
   selectFromTableFragment(options, model, attributes, tables, mainTableAs, where) {
     this._throwOnEmptyAttributes(attributes, { modelName: model && model.name, as: mainTableAs });
 
+    // mssql overwrite the abstract selectFromTableFragment function.
+    if (options.maxExecutionTimeHintMs != null) {
+      throw new Error(`The maxExecutionTimeMs option is not supported by ${this.dialect.name}`);
+    }
+
     return joinSQLFragments([
       'SELECT',
       attributes.join(', '),

diff --git a/packages/core/src/dialects/mysql/index.ts b/packages/core/src/dialects/mysql/index.ts
@@ -55,6 +55,9 @@ export class MysqlDialect extends AbstractDialect {
       jsonOperations: true,
       REGEXP: true,
       globalTimeZoneConfig: true,
+      maxExecutionTimeHint: {
+        select: true,
+      },
     },
   );
 

diff --git a/packages/core/src/dialects/mysql/query-generator.js b/packages/core/src/dialects/mysql/query-generator.js
@@ -1,5 +1,6 @@
 'use strict';
 
+import { inspect } from 'node:util';
 import { rejectInvalidOptions } from '../../utils/check';
 import { addTicks } from '../../utils/dialect';
 import { joinSQLFragments } from '../../utils/join-sql-fragments';
@@ -459,6 +460,25 @@ export class MySqlQueryGenerator extends MySqlQueryGeneratorTypeScript {
       ';',
     ]);
   }
+
+  _getBeforeSelectAttributesFragment(options) {
+    let fragment = '';
+
+    const MINIMUM_EXECUTION_TIME_VALUE = 0;
+    const MAXIMUM_EXECUTION_TIME_VALUE = 4_294_967_295;
+
+    if (options.maxExecutionTimeHintMs != null) {
+      if (Number.isSafeInteger(options.maxExecutionTimeHintMs)
+        && options.maxExecutionTimeHintMs >= MINIMUM_EXECUTION_TIME_VALUE
+        && options.maxExecutionTimeHintMs <= MAXIMUM_EXECUTION_TIME_VALUE) {
+        fragment += ` /*+ MAX_EXECUTION_TIME(${options.maxExecutionTimeHintMs}) */`;
+      } else {
+        throw new Error(`maxExecutionTimeMs must be between ${MINIMUM_EXECUTION_TIME_VALUE} and ${MAXIMUM_EXECUTION_TIME_VALUE}, but it is ${inspect(options.maxExecutionTimeHintMs)}`);
+      }
+    }
+
+    return fragment;
+  }
 }
 
 /**

diff --git a/packages/core/src/model.d.ts b/packages/core/src/model.d.ts
@@ -776,13 +776,21 @@ export interface IndexHintable {
   indexHints?: IndexHint[];
 }
 
+export interface MaxExecutionTimeHintable {
+  /**
+   * This sets the max execution time for MySQL.
+   */
+  maxExecutionTimeHintMs?: number;
+}
+
 /**
  * Options that are passed to any model creating a SELECT query
  *
  * A hash of options to describe the scope of the search
  */
 export interface FindOptions<TAttributes = any>
-  extends QueryOptions, Filterable<TAttributes>, Projectable, Paranoid, IndexHintable, SearchPathable {
+  extends
+  QueryOptions, Filterable<TAttributes>, Projectable, Paranoid, IndexHintable, SearchPathable, MaxExecutionTimeHintable {
   /**
    * A list of associations to eagerly load using a left join (a single association is also supported).
    *
@@ -915,7 +923,7 @@ export interface NonNullFindByPkOptions<M extends Model> extends Omit<NonNullFin
  * Options for Model.count method
  */
 export interface CountOptions<TAttributes = any>
-  extends Logging, Transactionable, Filterable<TAttributes>, Projectable, Paranoid, Poolable {
+  extends Logging, Transactionable, Filterable<TAttributes>, Projectable, Paranoid, Poolable, MaxExecutionTimeHintable {
   /**
    * Include options. See `find` for details
    */

diff --git a/packages/core/test/types/max-execution-time.ts b/packages/core/test/types/max-execution-time.ts
@@ -0,0 +1,6 @@
+import { IndexHints } from '@sequelize/core';
+import { User } from './models/user';
+
+User.findAll({
+  maxExecutionTimeHintMs: 1000,
+});
diff --git a/packages/core/test/unit/query-generator/select-query.test.ts b/packages/core/test/unit/query-generator/select-query.test.ts
@@ -2,7 +2,7 @@ import { expect } from 'chai';
 import type { InferAttributes, Model } from '@sequelize/core';
 import { DataTypes, Op, or, sql as sqlTag } from '@sequelize/core';
 import { _validateIncludedElements } from '@sequelize/core/_non-semver-use-at-your-own-risk_/model-internals.js';
-import { expectsql, sequelize } from '../../support';
+import { expectsql, getTestDialect, sequelize } from '../../support';
 
 const { attribute, col, cast, where, fn, literal } = sqlTag;
 
@@ -659,4 +659,21 @@ Only named replacements (:name) are allowed in literal() because we cannot guara
       });
     });
   });
+
+  describe('optimizer hints', () => {
+    const dialectName = getTestDialect();
+
+    it('max execution time hint', () => {
+      const notSupportedError = new Error(`The maxExecutionTimeMs option is not supported by ${dialectName}`);
+
+      expectsql(() => queryGenerator.selectQuery(User.tableName, {
+        model: User,
+        attributes: ['id'],
+        maxExecutionTimeHintMs: 1000,
+      }, User), {
+        default: notSupportedError,
+        mysql: 'SELECT /*+ MAX_EXECUTION_TIME(1000) */ `id` FROM `Users` AS `User`;',
+      });
+    });
+  });
 });