Indicateurs (Transact-SQL) - RequêteHints (Transact-SQL) - Query

S’APPLIQUE À : ouiSQL Server (à partir de 2008) ouiAzure SQL Database nonAzure SQL Data Warehouse nonParallel Data Warehouse APPLIES TO: yesSQL Server (starting with 2008) yesAzure SQL Database noAzure SQL Data Warehouse noParallel Data Warehouse

Les indicateurs de requête spécifient que les indicateurs affichés doivent être utilisés dans l'ensemble de la requête.Query hints specify that the indicated hints should be used throughout the query. Ils s’appliquent à tous les opérateurs de l’instruction.They affect all operators in the statement. Si une clause UNION se trouve dans la requête principale, seule la dernière requête impliquant une opération UNION peut avoir la clause OPTION.If UNION is involved in the main query, only the last query involving a UNION operation can have the OPTION clause. Les indicateurs de requête sont spécifiés dans la clause OPTION.Query hints are specified as part of the OPTION clause. L'erreur 8622 se produit si un ou plusieurs indicateurs de requête empêchent l'optimiseur de requête de générer un plan valide.Error 8622 occurs if one or more query hints cause the query optimizer not to generate a valid plan.

Attention

Étant donné que l'optimiseur de requête SQL ServerSQL Server sélectionne généralement le meilleur plan d'exécution pour une requête, nous recommandons de ne recourir aux indicateurs qu'en dernier ressort, et à condition d'être un développeur ou un administrateur de base de données expérimenté.Because the SQL ServerSQL Server query optimizer typically selects the best execution plan for a query, we recommend only using hints as a last resort for experienced developers and database administrators.

S’applique à :Applies to:

DELETEDELETE

INSERTINSERT

SELECTSELECT

UPDATEUPDATE

MERGEMERGE

SyntaxeSyntax

<query_hint > ::=   
{ { HASH | ORDER } GROUP   
  | { CONCAT | HASH | MERGE } UNION   
  | { LOOP | MERGE | HASH } JOIN   
  | EXPAND VIEWS   
  | FAST number_rows   
  | FORCE ORDER   
  | { FORCE | DISABLE } EXTERNALPUSHDOWN  
  | IGNORE_NONCLUSTERED_COLUMNSTORE_INDEX  
  | KEEP PLAN   
  | KEEPFIXED PLAN  
  | MAX_GRANT_PERCENT = percent  
  | MIN_GRANT_PERCENT = percent  
  | MAXDOP number_of_processors   
  | MAXRECURSION number   
  | NO_PERFORMANCE_SPOOL   
  | OPTIMIZE FOR ( @variable_name { UNKNOWN | = literal_constant } [ , ...n ] )  
  | OPTIMIZE FOR UNKNOWN  
  | PARAMETERIZATION { SIMPLE | FORCED }   
  | RECOMPILE  
  | ROBUST PLAN   
  | USE HINT ( '<hint_name>' [ , ...n ] )
  | USE PLAN N'xml_plan'  | TABLE HINT ( exposed_object_name [ , <table_hint> [ [, ]...n ] ] )  
}  
  
<table_hint> ::=  
[ NOEXPAND ] {   
    INDEX ( index_value [ ,...n ] ) | INDEX = ( index_value )  
  | FORCESEEK [( index_value ( index_column_name [,... ] ) ) ]  
  | FORCESCAN  
  | HOLDLOCK   
  | NOLOCK   
  | NOWAIT  
  | PAGLOCK   
  | READCOMMITTED   
  | READCOMMITTEDLOCK   
  | READPAST   
  | READUNCOMMITTED   
  | REPEATABLEREAD   
  | ROWLOCK   
  | SERIALIZABLE   
  | SNAPSHOT  
  | SPATIAL_WINDOW_MAX_CELLS = integer  
  | TABLOCK   
  | TABLOCKX   
  | UPDLOCK   
  | XLOCK  
}  

ArgumentsArguments

{ HASH | ORDER } GROUP{ HASH | ORDER } GROUP
Indique que les agrégations décrites par la clause GROUP BY ou DISTINCT de la requête doivent utiliser le hachage ou le tri.Specifies that aggregations that the query's GROUP BY or DISTINCT clause describes should use hashing or ordering.

{ MERGE | HASH | CONCAT } UNION{ MERGE | HASH | CONCAT } UNION
Indique que toutes les opérations UNION doivent être exécutées par fusion, hachage ou concaténation d'ensembles UNION.Specifies that all UNION operations are run by merging, hashing, or concatenating UNION sets. Si plusieurs indicateurs UNION sont spécifiées, l'optimiseur sélectionne la stratégie la moins coûteuse parmi les indicateurs spécifiés.If more than one UNION hint is specified, the query optimizer selects the least expensive strategy from those hints specified.

{ LOOP | MERGE | HASH } JOIN{ LOOP | MERGE | HASH } JOIN
Indique que toutes les opérations de jointure doivent être effectuées par LOOP JOIN, MERGE JOIN ou HASH JOIN dans toute la requête.Specifies all join operations are performed by LOOP JOIN, MERGE JOIN, or HASH JOIN in the whole query. Si plusieurs indicateurs de jointure sont spécifiés, l'optimiseur sélectionne la stratégie la moins coûteuse parmi celles qui sont autorisées.If you specify more than one join hint, the optimizer selects the least expensive join strategy from the allowed ones.

Si vous spécifiez un indicateur de jointure dans la clause FROM de la même requête pour une paire de tables spécifique, il est prioritaire dans la jointure des deux tables.If you specify a join hint in the same query's FROM clause for a specific table pair, this join hint takes precedence in the joining of the two tables. Les indicateurs de requête, toutefois, doivent quand même être respectés.The query hints, though, must still be honored. L'indicateur de jointure de la paire de tables peut seulement restreindre la sélection des méthodes de jointure autorisées dans l'indicateur de requête.The join hint for the pair of tables may only restrict the selection of allowed join methods in the query hint. Pour plus d’informations, consultez Indicateurs de jointure (Transact-SQL).For more information, see Join Hints (Transact-SQL).

EXPAND VIEWSEXPAND VIEWS
Indique que les vues indexées doivent être développées,Specifies the indexed views are expanded. et que l’optimiseur de requête ne doit pas prendre en compte de vues indexées en remplacement d’une partie de la requête.Also specifies the query optimizer won't consider any indexed view as a replacement for any query part. Une vue est développée lorsque sa définition remplace son nom dans le texte de la requête.A view is expanded when the view definition replaces the view name in the query text.

Cet indicateur de requête interdit virtuellement l'utilisation directe de vues indexées et d'index sur des vues indexées dans le plan de requête.This query hint virtually disallows direct use of indexed views and indexes on indexed views in the query plan.

La vue indexée reste condensée si une référence directe y est faite dans la partie SELECT de la requête,The indexed view remains condensed if there's a direct reference to the view in the query's SELECT part. ou si WITH (NOEXPAND) ou WITH (NOEXPAND, INDEX(valeur_index_ [ , …n ] ) ) est spécifié.The view also remains condensed if you specify WITH (NOEXPAND) or WITH (NOEXPAND, INDEX(index_value_ [ ,...n ] ) ). Pour plus d’informations sur l’indicateur de requête NOEXPAND, consultez Utilisation de NOEXPAND.For more information about the query hint NOEXPAND, see Using NOEXPAND.

L'indicateur n’a d’incidence que sur les vues de la partie SELECT des instructions, y compris celles figurant dans des instructions INSERT, UPDATE, MERGE et DELETE.The hint only affects the views in the statements' SELECT part, including those views in INSERT, UPDATE, MERGE, and DELETE statements.

FAST nombre_lignesFAST number_rows
Indique que la requête doit être optimisée pour permettre une récupération rapide des premières lignes définies par nombre_lignes.Specifies that the query is optimized for fast retrieval of the first number_rows. Ce résultat est un entier non négatif.This result is a nonnegative integer. Une fois les premières lignes définies par nombre_lignes retournées, la requête se poursuit pour retourner un jeu de résultats complet.After the first number_rows are returned, the query continues execution and produces its full result set.

FORCE ORDERFORCE ORDER
Spécifie que l'ordre de jointure spécifié dans la syntaxe de la requête est conservé au cours de l'optimisation de la requête.Specifies that the join order indicated by the query syntax is preserved during query optimization. FORCE ORDER n'a aucun effet sur un éventuel comportement d’inversion des rôles de la part de l'optimiseur de requête.Using FORCE ORDER doesn't affect possible role reversal behavior of the query optimizer.

Notes

Dans une instruction MERGE, il convient d'accéder à la table source avant la table cible comme ordre de jointure par défaut, à moins que la clause WHEN SOURCE NOT MATCHED ne soit spécifiée.In a MERGE statement, the source table is accessed before the target table as the default join order, unless the WHEN SOURCE NOT MATCHED clause is specified. La spécification de FORCE ORDER préserve ce comportement par défaut.Specifying FORCE ORDER preserves this default behavior.

{ FORCE | DISABLE } EXTERNALPUSHDOWN{ FORCE | DISABLE } EXTERNALPUSHDOWN
Force ou désactive la poussée vers le bas (pushdown) du calcul des expressions éligibles dans Hadoop.Force or disable the pushdown of the computation of qualifying expressions in Hadoop. S’applique uniquement aux requêtes avec PolyBase.Only applies to queries using PolyBase. Ne s’applique pas au stockage Azure.Won't push down to Azure storage.

KEEP PLANKEEP PLAN
Force l'optimiseur de requête à abaisser le seuil de recompilation estimé pour une requête.Forces the query optimizer to relax the estimated recompile threshold for a query. Le seuil de recompilation estimé lance une recompilation automatique de la requête lorsque le nombre estimé de modifications de colonnes indexées a été apporté à une table par exécution de l’une des instructions suivantes :The estimated recompile threshold starts an automatic recompile for the query when the estimated number of indexed column changes have been made to a table by running one of the following statements:

  • UPDATEUPDATE
  • SuppressionDELETE
  • MERGEMERGE
  • INSERTINSERT

KEEP PLAN permet de garantir qu'une requête n'est pas recompilée aussi fréquemment lorsque plusieurs mises à jour sont effectuées dans une table.Specifying KEEP PLAN makes sure a query won't be recompiled as frequently when there are multiple updates to a table.

KEEPFIXED PLANKEEPFIXED PLAN
Force l'optimiseur de requête à ne pas recompiler une requête en raison de modifications enregistrées au niveau des statistiques.Forces the query optimizer not to recompile a query because of changes in statistics. KEEPFIXED PLAN permet de garantir qu’une requête n’est recompilée que si le schéma des tables sous-jacentes est modifié ou si sp_recompile s’exécute sur ces tables.Specifying KEEPFIXED PLAN makes sure that a query recompiles only if the schema of the underlying tables changes or if sp_recompile runs against those tables.

IGNORE_NONCLUSTERED_COLUMNSTORE_INDEXIGNORE_NONCLUSTERED_COLUMNSTORE_INDEX
S'applique à: SQL Server 2012 (11.x)SQL Server 2012 (11.x) jusqu'à SQL Server 2017SQL Server 2017.Applies to: SQL Server 2012 (11.x)SQL Server 2012 (11.x) through SQL Server 2017SQL Server 2017.

Empêche la requête d’utiliser un index columnstore non-cluster à mémoire optimisée.Prevents the query from using a nonclustered memory optimized columnstore index. Si la requête contient l’indicateur de requête pour éviter l’utilisation de l’index columnstore et un indicateur d’index pour utiliser un index columnstore, les indicateurs sont en conflit et la requête retourne une erreur.If the query contains the query hint to avoid the use of the columnstore index, and an index hint to use a columnstore index, the hints are in conflict and the query returns an error.

MAX_GRANT_PERCENT = percentMAX_GRANT_PERCENT = percent
Taille de l’allocation maximale de mémoire, en pourcentage.The maximum memory grant size in PERCENT. La requête ne peut pas dépasser cette limite.The query is guaranteed not to exceed this limit. La limite réelle peut être inférieure si le paramètre de Resource Governor est inférieur à la valeur spécifiée par cet indicateur.The actual limit can be lower if the Resource Governor setting is lower than the value specified by this hint. Les valeurs valides sont comprises entre 0,0 et 100,0.Valid values are between 0.0 and 100.0.

S'applique à: SQL Server 2016 (13.x)SQL Server 2016 (13.x) jusqu'à SQL Server 2017SQL Server 2017.Applies to: SQL Server 2016 (13.x)SQL Server 2016 (13.x) through SQL Server 2017SQL Server 2017.

MIN_GRANT_PERCENT = percentMIN_GRANT_PERCENT = percent
Taille de l’allocation minimale de mémoire, en pourcentage de la limite par défaut.The minimum memory grant size in PERCENT = % of default limit. La requête est assurée d’avoir au moins la mémoire nécessaire pour pouvoir s’exécuter.The query is guaranteed to get MAX(required memory, min grant) because at least required memory is needed to start a query. Les valeurs valides sont comprises entre 0,0 et 100,0.Valid values are between 0.0 and 100.0.

S'applique à: SQL Server 2016 (13.x)SQL Server 2016 (13.x) jusqu'à SQL Server 2017SQL Server 2017.Applies to: SQL Server 2016 (13.x)SQL Server 2016 (13.x) through SQL Server 2017SQL Server 2017.

MAXDOP numberMAXDOP number
S'applique à: SQL Server 2008SQL Server 2008 jusqu'à SQL Server 2017SQL Server 2017.Applies to: SQL Server 2008SQL Server 2008 through SQL Server 2017SQL Server 2017.

Remplace l’option de configuration Degré maximal de parallélisme de sp_configure.Overrides the max degree of parallelism configuration option of sp_configure. Remplace également Resource Governor pour la requête spécifiant cette option.Also overrides the Resource Governor for the query specifying this option. L'indicateur de requête MAXDOP peut dépasser la valeur configurée avec sp_configure.The MAXDOP query hint can exceed the value configured with sp_configure. Si MAXDOP dépasse la valeur configurée avec Resource Governor, le Moteur de base de donnéesDatabase Engine utilise la valeur MAXDOP de Resource Governor, décrite dans ALTER WORKLOAD GROUP (Transact-SQL).If MAXDOP exceeds the value configured with Resource Governor, the Moteur de base de donnéesDatabase Engine uses the Resource Governor MAXDOP value, described in ALTER WORKLOAD GROUP (Transact-SQL). Toutes les règles sémantiques utilisées avec l’option de configuration max degree of parallelism sont applicables quand vous utilisez l’indicateur de requête MAXDOP.All semantic rules used with the max degree of parallelism configuration option are applicable when you use the MAXDOP query hint. Pour plus d’informations, consultez Configurer l’option de configuration du serveur max degree of parallelism.For more information, see Configure the max degree of parallelism Server Configuration Option.

Avertissement

Si MAXDOP a la valeur zéro, le serveur choisit le degré maximal de parallélisme.If MAXDOP is set to zero, then the server chooses the max degree of parallelism.

MAXRECURSION number MAXRECURSION number
Spécifie le nombre maximal de récursivités autorisé pour cette requête.Specifies the maximum number of recursions allowed for this query. number est un entier non négatif compris entre 0 et 32 767.number is a nonnegative integer between 0 and 32,767. Lorsque 0 est spécifié, aucune limite n'est appliquée.When 0 is specified, no limit is applied. Si cette option n'est pas spécifiée, la limite par défaut du serveur est 100.If this option isn't specified, the default limit for the server is 100.

Lorsque la limite par défaut ou spécifiée de MAXRECURSION est atteinte au cours de l'exécution d'une requête, cette requête se termine en retournant une erreur.When the specified or default number for MAXRECURSION limit is reached during query execution, the query ends and an error returns.

À cause de cette erreur, tous les effets de l'instruction sont annulés.Because of this error, all effects of the statement are rolled back. S'il s'agit d'une instruction SELECT, les résultats retournés sont partiels ou aucun résultat n'est retourné.If the statement is a SELECT statement, partial results or no results may be returned. Il se peut que parmi les résultats partiels éventuellement retournés ne figurent pas toutes les lignes des niveaux de récursivité supérieurs au niveau de récursivité maximal spécifié.Any partial results returned may not include all rows on recursion levels beyond the specified maximum recursion level.

Pour plus d’informations, consultez WITH common_table_expression (Transact-SQL).For more information, see WITH common_table_expression (Transact-SQL).

NO_PERFORMANCE_SPOOLNO_PERFORMANCE_SPOOL
S'applique à: SQL Server 2016 (13.x)SQL Server 2016 (13.x) jusqu'à SQL Server 2017SQL Server 2017.Applies to: SQL Server 2016 (13.x)SQL Server 2016 (13.x) through SQL Server 2017SQL Server 2017.

Empêche l’ajout d’un opérateur de spool aux plans de requête (à l’exception des plans où un spool est nécessaire pour garantir la validité de la sémantique de mise à jour).Prevents a spool operator from being added to query plans (except for the plans when spool is required to guarantee valid update semantics). L’opérateur de spool est susceptible de diminuer les performances dans certains scénarios.The spool operator may reduce performance in some scenarios. Par exemple, du fait que le spool utilise tempdb, une contention de tempdb peut se produire quand un grand nombre de requêtes simultanées sont exécutées avec les opérations de spool.For example, the spool uses tempdb and tempdb contention can occur if there are many concurrent queries running with the spool operations.

OPTIMIZE FOR ( _@variable\_nom_ { UNKNOWN | = constante_littérale } [ ,n ] )OPTIMIZE FOR ( _@variable\_name_ { UNKNOWN | = literal_constant } [ , ...n ] )
Indique à l'optimiseur de requête d'attribuer à une variable locale une valeur déterminée lors de la compilation et de l'optimisation de la requête.Instructs the query optimizer to use a particular value for a local variable when the query is compiled and optimized. Cette valeur n'est utilisée que pendant l'optimisation de la requête, et non pas lors de son exécution.The value is used only during query optimization, and not during query execution.

@variable\_nom_@variable\_name_
Nom d'une variable locale utilisée dans une requête, à laquelle une valeur peut être attribuée pour être utilisée avec l'indicateur de requête OPTIMIZE FOR.Is the name of a local variable used in a query, to which a value may be assigned for use with the OPTIMIZE FOR query hint.

UNKNOWNUNKNOWN
Spécifie que l’optimiseur de requête utilise des données statistiques à la place de la valeur initiale pour déterminer la valeur d’une variable locale pendant l’optimisation de requête.Specifies that the query optimizer uses statistical data instead of the initial value to determine the value for a local variable during query optimization.

constante_littéraleliteral_constant
Valeur de constante littérale à assigner à _@variable\_nom_ pour l’utiliser avec l’indicateur de requête OPTIMIZE FOR.Is a literal constant value to be assigned _@variable\_name_ for use with the OPTIMIZE FOR query hint. constante_littérale n’est utilisé que pendant l’optimisation de la requête, et non comme valeur de _@variable\_nom_ lors de l’exécution de la requête.literal_constant is used only during query optimization, and not as the value of _@variable\_name_ during query execution. constante_littérale peut être de n’importe quel type de données système SQL ServerSQL Server qui peut être exprimé sous forme de constante littérale.literal_constant can be of any SQL ServerSQL Server system data type that can be expressed as a literal constant. Le type de données de constante_littérale doit être implicitement convertible dans le type de données auquel _@variable\_nom_ fait référence dans la requête.The data type of literal_constant must be implicitly convertible to the data type that _@variable\_name_ references in the query.

OPTIMIZE FOR peut contrecarrer le comportement de détection des paramètres par défaut de l’optimiseur.OPTIMIZE FOR can counteract the optimizer's default parameter detection behavior. Utilisez également OPTIMIZE FOR pour créer des repères de plan.Also use OPTIMIZE FOR when you create plan guides. Pour plus d’informations, consultez Recompiler une procédure stockée.For more information, see Recompile a Stored Procedure.

OPTIMIZE FOR UNKNOWNOPTIMIZE FOR UNKNOWN
Indique à l'optimiseur de requête d'utiliser des données statistiques au lieu des valeurs initiales pour toutes les variables locales lorsque la requête est compilée et optimisée.Instructs the query optimizer to use statistical data instead of the initial values for all local variables when the query is compiled and optimized. Cette optimisation englobe les paramètres créés avec un paramétrage forcé.This optimization includes parameters created with forced parameterization.

Si OPTIMIZE FOR @variable_name = constante_littérale et OPTIMIZE FOR UNKNOWN sont utilisés dans le même indicateur de requête, l’optimiseur de requête utilise la constante_littérale indiquée pour une valeur spécifiqueIf you use OPTIMIZE FOR @variable_name = literal_constant and OPTIMIZE FOR UNKNOWN in the same query hint, the query optimizer will use the literal_constant specified for a specific value. et UNKNOWN pour les autres valeurs des variables.The query optimizer will use UNKNOWN for the rest of the variable values. Les valeurs ne sont utilisées que pendant l'optimisation de la requête, et non pas lors de son exécution.The values are used only during query optimization, and not during query execution.

PARAMETERIZATION { SIMPLE | FORCED }PARAMETERIZATION { SIMPLE | FORCED }
Indique les règles de paramétrage que l'optimiseur de requête SQL ServerSQL Server doit appliquer à la requête lors de sa compilation.Specifies the parameterization rules that the SQL ServerSQL Server query optimizer applies to the query when it's compiled.

Important

L’indicateur de requête PARAMETERIZATION peut uniquement être spécifié à l’intérieur d’un repère de plan pour remplacer le paramètre actuel de l’option SET de base de données PARAMETERIZATION.The PARAMETERIZATION query hint can only be specified inside a plan guide to override the current setting of the PARAMETERIZATION database SET option. Il n’est pas possible de le spécifier directement dans une requête.It can't be specified directly within a query.
Pour plus d’informations, consultez Spécifier le comportement du paramétrage de requêtes grâce aux repères de plan.For more information, see Specify Query Parameterization Behavior by Using Plan Guides.

SIMPLE indique à l'optimiseur de requête de tenter le processus de paramétrage simple.SIMPLE instructs the query optimizer to attempt simple parameterization. FORCED indique à l’optimiseur de requête de tenter le processus de paramétrage forcé.FORCED instructs the query optimizer to attempt forced parameterization. Pour plus d’informations, consultez Paramétrage forcé dans le Guide d’architecture de traitement des requêtes et Paramétrage simple dans le Guide d’architecture de traitement des requêtes.For more information, see Forced Parameterization in the Query Processing Architecture Guide, and Simple Parameterization in the Query Processing Architecture Guide.

RECOMPILERECOMPILE
Envoie à Moteur de base de données SQL ServerSQL Server Database Engine l’instruction de générer un nouveau plan temporaire pour la requête et de l’abandonner juste après la fin d’exécution de la requête.Instructs the Moteur de base de données SQL ServerSQL Server Database Engine to generate a new, temporary plan for the query and immediately discard that plan after the query completes execution. Le plan de requête généré ne remplace pas un plan stocké en cache lorsque la même requête s’exécute sans l’indicateur RECOMPILE.The generated query plan doesn't replace a plan stored in cache when the same query runs without the RECOMPILE hint. Si RECOMPILE n’est pas spécifié, le Moteur de base de donnéesDatabase Engine met en cache les plans de requête et les réutilise.Without specifying RECOMPILE, the Moteur de base de donnéesDatabase Engine caches query plans and reuses them. Lors de la compilation de plans de requête, l’indicateur de requête RECOMPILE utilise les valeurs actuelles des éventuelles variables locales dans la requête.When compiling query plans, the RECOMPILE query hint uses the current values of any local variables in the query. Si la requête se trouve à l’intérieur d’une procédure stockée, les valeurs actuelles sont transmises aux paramètres.If the query is inside a stored procedure, the current values passed to any parameters.

RECOMPILE est utile pour ne pas avoir à créer une procédure stockée.RECOMPILE is a useful alternative to creating a stored procedure. RECOMPILE utilise la clause WITH RECOMPILE lorsqu'il s'agit seulement de recompiler un sous-ensemble de requêtes dans la procédure stockée, et non la totalité de celle-ci.RECOMPILE uses the WITH RECOMPILE clause when only a subset of queries inside the stored procedure, instead of the whole stored procedure, must be recompiled. Pour plus d’informations, consultez Recompiler une procédure stockée.For more information, see Recompile a Stored Procedure. RECOMPILE s'avère également utile pour créer des repères de guides.RECOMPILE is also useful when you create plan guides.

ROBUST PLANROBUST PLAN
Force l'optimiseur de requête à essayer un plan capable de prendre en charge la taille maximale potentielle des lignes, éventuellement aux dépens des performances.Forces the query optimizer to try a plan that works for the maximum potential row size, possibly at the expense of performance. Lors du traitement de la requête, les tables et les opérateurs intermédiaires peuvent avoir à stocker et à traiter des lignes plus grandes que n'importe quelle ligne d'entrée.When the query is processed, intermediate tables and operators may have to store and process rows that are wider than any one of the input rows when the query is processed. Elles sont parfois si grandes que l'opérateur particulier ne peut pas les traiter.The rows may be so wide that, sometimes, the particular operator can't process the row. Dans ce cas, le Moteur de base de donnéesDatabase Engine génère une erreur lors de l'exécution de la requête.If rows are that wide, the Moteur de base de donnéesDatabase Engine produces an error during query execution. ROBUST PLAN permet d’indiquer à l'optimiseur de requête de ne considérer aucun plan de requête susceptible de présenter ce problème.By using ROBUST PLAN, you instruct the query optimizer not to consider any query plans that may run into this problem.

Si un tel plan n'est pas possible, l'optimiseur de requête retourne une erreur plutôt que de différer la détection de l'erreur au moment de l'exécution de la requête.If such a plan isn't possible, the query optimizer returns an error instead of deferring error detection to query execution. Les lignes peuvent contenir des colonnes de longueur variable. Le Moteur de base de donnéesDatabase Engine permet de définir des lignes d’une taille maximale potentielle que le Moteur de base de donnéesDatabase Engine n’est pas en mesure de traiter.Rows may contain variable-length columns; the Moteur de base de donnéesDatabase Engine allows for rows to be defined that have a maximum potential size beyond the ability of the Moteur de base de donnéesDatabase Engine to process them. En règle générale, en dépit de la taille maximale potentielle, une application stocke des lignes dont la taille réelle est comprise dans les limites gérées par le Moteur de base de donnéesDatabase Engine.Generally, despite the maximum potential size, an application stores rows that have actual sizes within the limits that the Moteur de base de donnéesDatabase Engine can process. Si Moteur de base de donnéesDatabase Engine rencontre une ligne trop longue, il retourne une erreur d'exécution.If the Moteur de base de donnéesDatabase Engine comes across a row that is too long, an execution error is returned.

USE HINT ( ' nom_indicateur ' )USE HINT ( 'hint_name' )
S’applique à : SQL ServerSQL Server (depuis SQL Server 2016 (13.x)SQL Server 2016 (13.x) SP1) et Azure SQL DatabaseAzure SQL Database.Applies to: SQL ServerSQL Server (starting with SQL Server 2016 (13.x)SQL Server 2016 (13.x) SP1) and Azure SQL DatabaseAzure SQL Database.

Fournit au processeur de requêtes un ou plusieurs indicateurs supplémentaires,Provides one or more additional hints to the query processor. spécifiés par un nom entre guillemets simples.The additional hints are specified by a hint name inside single quotation marks.

Les noms d’indicateur suivants sont pris en charge :The following hint names are supported:

  • 'ASSUME_JOIN_PREDICATE_DEPENDS_ON_FILTERS' 'ASSUME_JOIN_PREDICATE_DEPENDS_ON_FILTERS'
    Indique à SQL ServerSQL Server de générer un plan de requête qui utilise l’hypothèse de relation contenant-contenu simple, au lieu de l’hypothèse par défaut de relation contenant-contenu de base pour les jointures, avec le modèle d’estimation de la cardinalité de l’optimiseur de requête fourni dans SQL Server 2014 (12.x)SQL Server 2014 (12.x) ou ultérieur.Causes SQL ServerSQL Server to generate a query plan using the Simple Containment assumption instead of the default Base Containment assumption for joins, under the query optimizer Cardinality Estimation model of SQL Server 2014 (12.x)SQL Server 2014 (12.x) or newer. Ce nom d’indicateur équivaut à l’indicateur de trace 9476.This hint name is equivalent to trace flag 9476.

  • 'ASSUME_MIN_SELECTIVITY_FOR_FILTER_ESTIMATES' 'ASSUME_MIN_SELECTIVITY_FOR_FILTER_ESTIMATES'
    Indique à SQL ServerSQL Server de générer un plan qui utilise la sélectivité minimale lors de l’évaluation des prédicats AND des filtres pour la prise en compte de la corrélation.Causes SQL ServerSQL Server to generate a plan using minimum selectivity when estimating AND predicates for filters to account for correlation. Ce nom d’indicateur équivaut à l’indicateur de trace 4137 avec le modèle d’estimation de la cardinalité fourni dans SQL Server 2012 (11.x)SQL Server 2012 (11.x) et les versions antérieures, ou à l’indicateur de trace 9471 avec le modèle d’estimation de la cardinalité disponible dans SQL Server 2014 (12.x)SQL Server 2014 (12.x) ou versions ultérieures.This hint name is equivalent to trace flag 4137 when used with cardinality estimation model of SQL Server 2012 (11.x)SQL Server 2012 (11.x) and earlier versions, and has similar effect when trace flag 9471 is used with cardinality estimation model of SQL Server 2014 (12.x)SQL Server 2014 (12.x) or higher.

  • 'DISABLE_BATCH_MODE_ADAPTIVE_JOINS''DISABLE_BATCH_MODE_ADAPTIVE_JOINS'
    Désactive les jointures adaptatives en mode batch.Disables batch mode adaptive joins. Pour plus d’informations, consultez Jointures adaptatives en mode batch.For more information, see Batch mode Adaptive Joins. S’applique à : SQL ServerSQL Server (à compter de SQL Server 2017 (14.x)SQL Server 2017 (14.x)) et Azure SQL DatabaseAzure SQL Database.Applies to: SQL ServerSQL Server (starting with SQL Server 2017 (14.x)SQL Server 2017 (14.x)) and Azure SQL DatabaseAzure SQL Database.

  • 'DISABLE_BATCH_MODE_MEMORY_GRANT_FEEDBACK''DISABLE_BATCH_MODE_MEMORY_GRANT_FEEDBACK'
    Désactive les retours d’allocation de mémoire en mode batch.Disables batch mode memory grant feedback. Pour plus d’informations, consultez Retour d’allocation de mémoire en mode batch.For more information, see Batch mode memory grant feedback. S’applique à : SQL ServerSQL Server (à compter de SQL Server 2017 (14.x)SQL Server 2017 (14.x)) et Azure SQL DatabaseAzure SQL Database.Applies to: SQL ServerSQL Server (starting with SQL Server 2017 (14.x)SQL Server 2017 (14.x)) and Azure SQL DatabaseAzure SQL Database.

  • 'DISABLE_DEFERRED_COMPILATION_TV''DISABLE_DEFERRED_COMPILATION_TV'
    Désactive la compilation différée de variable de table.Disables table variable deferred compilation. Pour plus d'informations, consultez Compilation différée de variable de table.For more information, see Table variable deferred compilation. S’applique à : SQL ServerSQL Server (à compter de SQL Server 2019 - PreviewSQL Server 2019 preview) et Azure SQL DatabaseAzure SQL Database.Applies to: SQL ServerSQL Server (starting with SQL Server 2019 - PreviewSQL Server 2019 preview) and Azure SQL DatabaseAzure SQL Database.

  • 'DISABLE_INTERLEAVED_EXECUTION_TVF''DISABLE_INTERLEAVED_EXECUTION_TVF'
    Désactive l’exécution entrelacée pour les fonctions table à instructions multiples.Disables interleaved execution for multi-statement table-valued functions. Pour plus d’informations, voir Exécution entrelacée pour les fonctions table à instructions multiples.For more information, see Interleaved execution for multi-statement table-valued functions. S’applique à : SQL ServerSQL Server (à compter de SQL Server 2017 (14.x)SQL Server 2017 (14.x)) et Azure SQL DatabaseAzure SQL Database.Applies to: SQL ServerSQL Server (starting with SQL Server 2017 (14.x)SQL Server 2017 (14.x)) and Azure SQL DatabaseAzure SQL Database.

  • 'DISABLE_OPTIMIZED_NESTED_LOOP''DISABLE_OPTIMIZED_NESTED_LOOP'
    Indique au processeur de requêtes de ne pas appliquer d’opération de tri (tri par lots) sur les jointures de boucles imbriquées optimisées au moment de la génération d’un plan de requête.Instructs the query processor not to use a sort operation (batch sort) for optimized nested loop joins when generating a query plan. Ce nom d’indicateur équivaut à l’indicateur de trace 2340.This hint name is equivalent to trace flag 2340.

  • 'DISABLE_OPTIMIZER_ROWGOAL' 'DISABLE_OPTIMIZER_ROWGOAL'
    Indique à SQL Server de générer un plan qui n’utilise pas les modifications de l’objectif des lignes avec des requêtes contenant ces mots clés :Causes SQL Server to generate a plan that doesn't use row goal modifications with queries that contain these keywords:

    • Haut de la pageTOP
    • OPTION (FAST N)OPTION (FAST N)
    • ININ
    • EXISTSEXISTS

    Ce nom d’indicateur équivaut à l’indicateur de trace 4138.This hint name is equivalent to trace flag 4138.

  • 'DISABLE_PARAMETER_SNIFFING''DISABLE_PARAMETER_SNIFFING'
    Indique à l’optimiseur de requête d’utiliser la distribution moyenne des données lors de la compilation d’une requête comportant un ou plusieurs paramètres.Instructs query optimizer to use average data distribution while compiling a query with one or more parameters. Cette instruction rend le plan de requête indépendant de la valeur du paramètre utilisée initialement lors de la compilation de la requête.This instruction makes the query plan independent on the parameter value that was first used when the query was compiled. Ce nom d’indicateur équivaut à l’indicateur de trace 4136 ou au paramètre de configuration au niveau base de données PARAMETER_SNIFFING = OFF.This hint name is equivalent to trace flag 4136 or Database Scoped Configuration setting PARAMETER_SNIFFING = OFF.

  • 'DISABLE_ROW_MODE_MEMORY_GRANT_FEEDBACK''DISABLE_ROW_MODE_MEMORY_GRANT_FEEDBACK'
    Désactive la rétroaction d’allocation de mémoire en mode ligne.Disables row mode memory grant feedback. Pour plus d’informations, consultez Rétroaction d’allocation de mémoire en mode ligne.For more information, see Row mode memory grant feedback. S’applique à : SQL ServerSQL Server (à compter de SQL Server 2019 - PreviewSQL Server 2019 preview) et Azure SQL DatabaseAzure SQL Database.Applies to: SQL ServerSQL Server (starting with SQL Server 2019 - PreviewSQL Server 2019 preview) and Azure SQL DatabaseAzure SQL Database.

  • 'DISABLE_TSQL_SCALAR_UDF_INLINING''DISABLE_TSQL_SCALAR_UDF_INLINING'
    Désactive l’incorporation des fonctions UDF scalaires.Disables scalar UDF inlining. Pour plus d’informations, consultez Incorporation des fonctions UDF scalaires.For more information, see Scalar UDF Inlining. S’applique à : SQL ServerSQL Server (à compter de SQL Server 2019 - PreviewSQL Server 2019 preview).Applies to: SQL ServerSQL Server (starting with SQL Server 2019 - PreviewSQL Server 2019 preview).

  • 'DISALLOW_BATCH_MODE''DISALLOW_BATCH_MODE'
    Désactive l’exécution en mode batch.Disables batch mode execution. Pour plus d’informations, consultez Modes d’exécution.For more information, see Execution modes. S’applique à : SQL ServerSQL Server (à compter de SQL Server 2017 (14.x)SQL Server 2017 (14.x)) et Azure SQL DatabaseAzure SQL Database.Applies to: SQL ServerSQL Server (starting with SQL Server 2017 (14.x)SQL Server 2017 (14.x)) and Azure SQL DatabaseAzure SQL Database.

  • 'ENABLE_HIST_AMENDMENT_FOR_ASC_KEYS''ENABLE_HIST_AMENDMENT_FOR_ASC_KEYS'
    Active automatiquement la génération de statistiques rapides (modification de l’histogramme) pour les colonnes d’index de début où l’estimation de la cardinalité est nécessaire.Enables automatically generated quick statistics (histogram amendment) for any leading index column for which cardinality estimation is needed. L’histogramme utilisé pour estimer la cardinalité est ajusté au moment de la compilation des requêtes pour prendre en compte la valeur minimale ou maximale réelle de chaque colonne.The histogram used to estimate cardinality will be adjusted at query compile time to account for actual maximum or minimum value of this column. Ce nom d’indicateur équivaut à l’indicateur de trace 4139.This hint name is equivalent to trace flag 4139.

  • 'ENABLE_QUERY_OPTIMIZER_HOTFIXES''ENABLE_QUERY_OPTIMIZER_HOTFIXES'
    Active les correctifs de l’optimiseur de requête (modifications publiées dans les Service Packs et mises à jour cumulatives SQL Server).Enables query optimizer hotfixes (changes released in SQL Server Cumulative Updates and Service Packs). Ce nom d’indicateur équivaut à l’indicateur de trace 4199 ou au paramètre de configuration au niveau base de données QUERY_OPTIMIZER_HOTFIXES = ON.This hint name is equivalent to trace flag 4199 or Database Scoped Configuration setting QUERY_OPTIMIZER_HOTFIXES = ON.

  • 'FORCE_DEFAULT_CARDINALITY_ESTIMATION''FORCE_DEFAULT_CARDINALITY_ESTIMATION'
    Force l’optimiseur de requête à utiliser le modèle d’estimation de la cardinalité qui correspond au niveau de compatibilité de la base de données.Forces the Query Optimizer to use Cardinality Estimation model that corresponds to the current database compatibility level. Cet indicateur remplace le paramètre de configuration au niveau base de données LEGACY_CARDINALITY_ESTIMATION = ON ou l’indicateur de trace 9481.Use this hint to override Database Scoped Configuration setting LEGACY_CARDINALITY_ESTIMATION = ON or trace flag 9481.

  • 'FORCE_LEGACY_CARDINALITY_ESTIMATION' 'FORCE_LEGACY_CARDINALITY_ESTIMATION'
    Force l’optimiseur de requête à utiliser le modèle Estimation de cardinalité fourni dans SQL Server 2012 (11.x)SQL Server 2012 (11.x) et les versions antérieures.Forces the query optimizer to use Cardinality Estimation model of SQL Server 2012 (11.x)SQL Server 2012 (11.x) and earlier versions. Ce nom d’indicateur équivaut à l’indicateur de trace 9481 ou au paramètre de configuration au niveau base de données LEGACY_CARDINALITY_ESTIMATION = ON.This hint name is equivalent to trace flag 9481 or Database Scoped Configuration setting LEGACY_CARDINALITY_ESTIMATION = ON.

  • 'QUERY_OPTIMIZER_COMPATIBILITY_LEVEL_n''QUERY_OPTIMIZER_COMPATIBILITY_LEVEL_n'
    Force le comportement de l’optimiseur de requête au niveau de la requête,Forces the query optimizer behavior at a query level. comme si celle-ci était compilée avec le niveau de compatibilité de la base de données n, où n est un niveau pris en charge.This behavior happens as if the query was compiled with database compatibility level n, where n is a supported database compatibility level. Consultez sys.dm_exec_valid_use_hints pour obtenir la liste des valeurs actuellement prises en charge pour n.Refer to sys.dm_exec_valid_use_hints for a list of currently supported values for n. S’applique à : SQL ServerSQL Server (à partir de SQL Server 2017 (14.x)SQL Server 2017 (14.x) CU10).Applies to: SQL ServerSQL Server (starting with SQL Server 2017 (14.x)SQL Server 2017 (14.x) CU10).

    Notes

    L’indicateur QUERY_OPTIMIZER_COMPATIBILITY_LEVEL_n ne remplace pas le paramètre d’estimation de la cardinalité hérité ou par défaut, s’il est forcé par le biais de la configuration de portée de base de données, l’indicateur de trace ou un autre indicateur de requête comme QUERYTRACEON.The QUERY_OPTIMIZER_COMPATIBILITY_LEVEL_n hint doesn't override default or legacy cardinality estimation setting, if it's forced through database scoped configuration, trace flag or another query hint such as QUERYTRACEON.
    Cet indicateur affecte uniquement le comportement de l’optimiseur de requête.This hint only affects the behavior of the query optimizer. Il n’a aucun effet sur les autres fonctionnalités de SQL ServerSQL Server susceptibles de dépendre du niveau de compatibilité de la base de données, comme la disponibilité de certaines fonctionnalités de la base de données.It doesn't affect other features of SQL ServerSQL Server that may depend on the database compatibility level, such as the availability of certain database features.
    Pour en savoir plus sur cet indicateur, consultez Developer’s Choice: Hinting Query Execution model.To learn more about this hint, see Developer's Choice: Hinting Query Execution model.

  • 'QUERY_PLAN_PROFILE''QUERY_PLAN_PROFILE'
    Permet un profilage léger pour la requête.Enables lightweight profiling for the query. À la fin d’une requête contenant ce nouvel indicateur, un nouvel événement étendu, query_plan_profile, est déclenché.When a query that contains this new hint finishes, a new Extended Event, query_plan_profile, is fired. Cet événement étendu expose les statistiques d’exécution et le plan d’exécution réel XML semblable à l’événement étendu query_post_execution_showplan, mais uniquement pour les requêtes qui contiennent le nouvel indicateur.This extended event exposes execution statistics and actual execution plan XML similar to the query_post_execution_showplan extended event but only for queries that contains the new hint. S’applique à : SQL ServerSQL Server (à partir de SQL Server 2016 (13.x)SQL Server 2016 (13.x) SP2CU3 et SQL Server 2017 (14.x)SQL Server 2017 (14.x) CU11).Applies to: SQL ServerSQL Server (starting with SQL Server 2016 (13.x)SQL Server 2016 (13.x) SP2 CU3 and SQL Server 2017 (14.x)SQL Server 2017 (14.x) CU11).

    Notes

    Si vous activez la collecte de l’événement étendu query_post_execution_showplan, cette opération ajoutera l’infrastructure de profilage standard à chaque requête qui est en cours d’exécution sur le serveur et pourra, par conséquent, affecter les performances globales du serveur.If you enable collecting the query_post_execution_showplan extended event, this will add standard profiling infrastructure to every query that is running on the server and therefore may affect overall server performance.
    Si vous activez la collection de l’événement étendu query_thread_profile pour utiliser l’infrastructure à profilage léger à la place, la performance sera beaucoup plus faible, mais les performances globales du serveur seront quand même affectées.If you enable the collection of query_thread_profile extended event to use lightweight profiling infrastructure instead, this will result in much less performance overhead but will still affect overall server performance.
    Si vous activez l’événement étendu query_plan_profile, cela activera uniquement l’infrastructure de profilage léger pour une requête exécutée avec le QUERY_PLAN_PROFILE et, par conséquent, n’affectera pas d’autres charges de travail sur le serveur.If you enable the query_plan_profile extended event, this will only enable the lightweight profiling infrastructure for a query that executed with the QUERY_PLAN_PROFILE and therefore will not affect other workloads on the server. Utilisez cet indicateur pour profiler une requête spécifique sans affecter d’autres parties de la charge de travail du serveur.Use this hint to profile a specific query without affecting other parts of the server workload. Pour en savoir plus sur le profilage léger, consultez Infrastructure du profilage de requête.To learn more about lightweight profiling, see Query Profiling Infrastructure.

Vous pouvez obtenir la liste de tous les noms d’indicateur USE HINT pris en charge en effectuant une requête sur la vue de gestion dynamique sys.dm_exec_valid_use_hints.The list of all supported USE HINT names can be queried using the dynamic management view sys.dm_exec_valid_use_hints.

Conseil

Les noms d’indicateur respectent la casse.Hint names are case-insensitive.

Important

Certains indicateurs USE HINT peuvent être en conflit avec des indicateurs de trace activés au niveau global ou session, ou avec des paramètres de configuration au niveau base de données.Some USE HINT hints may conflict with trace flags enabled at the global or session level, or database scoped configuration settings. Dans ce cas, l’indicateur de niveau requête (USE HINT) est toujours prioritaire.In this case, the query level hint (USE HINT) always takes precedence. En présence d’un conflit entre l’indicateur USE HINT et un autre indicateur de requête ou un indicateur de trace activé au niveau requête (par exemple, par QUERYTRACEON), SQL ServerSQL Server génère une erreur quand vous tentez d’exécuter la requête.If a USE HINT conflicts with another query hint, or a trace flag enabled at the query level (such as by QUERYTRACEON), SQL ServerSQL Server will generate an error when trying to execute the query.

USE PLAN N ' xml_plan ' USE PLAN N 'xml_plan'
Force l’optimiseur de requête à utiliser un plan de requête existant pour une requête spécifiée par ' xml_plan ' .Forces the query optimizer to use an existing query plan for a query that is specified by 'xml_plan'. Il n’est pas possible de spécifier USE PLAN avec des instructions INSERT, UPDATE, MERGE ou DELETE.USE PLAN can't be specified with INSERT, UPDATE, MERGE, or DELETE statements.

TABLE HINT ( nom_objet_exposé [ , <indicateur_table> [ [ , ]…n ] ] ) Applique l’indicateur de table spécifié à la table ou à la vue correspondant à nom_objet_exposé.TABLE HINT (exposed_object_name [ , <table_hint> [ [, ]...n ] ] ) Applies the specified table hint to the table or view that corresponds to exposed_object_name. Nous vous recommandons d’utiliser un indicateur de table comme indicateur de requête uniquement dans le contexte d’un repère de plan.We recommend using a table hint as a query hint only in the context of a plan guide.

nom_objet_exposé peut être l’une des références suivantes :exposed_object_name can be one of the following references:

  • Quand un alias est utilisé pour la table ou la vue dans la clause FROM de la requête, nom_objet_exposé est cet alias.When an alias is used for the table or view in the FROM clause of the query, exposed_object_name is the alias.

  • Si aucun alias n’est utilisé, nom_objet_exposé est la correspondance à l’exact de la table ou de la vue à laquelle il est fait référence dans la clause FROM.When an alias isn't used, exposed_object_name is the exact match of the table or view referenced in the FROM clause. Par exemple, si la référence à la table ou à la vue consiste en un nom en deux parties, nom_objet_exposé correspond au même nom en deux parties.For example, if the table or view is referenced using a two-part name, exposed_object_name is the same two-part name.

Si nom_objet_exposé est spécifié sans indicateur de table, tous les index indiqués dans la requête dans le cadre d’un indicateur de table de l’objet sont ignorés.When you specify exposed_object_name without also specifying a table hint, any indexes you specify in the query as part of a table hint for the object are disregarded. L’optimiseur de requête détermine ensuite l’utilisation de l’index.The query optimizer then determines index usage. Vous pouvez utiliser cette technique pour éliminer l'effet d'un indicateur de table INDEX lorsque vous ne pouvez pas modifier la requête d'origine.You can use this technique to eliminate the effect of an INDEX table hint when you can't modify the original query. Voir l'exemple J.See Example J.

<indicateur_table> ::= { [ NOEXPAND ] { INDEX ( valeur_index [ ,…n ] ) | INDEX = ( valeur_index ) | FORCESEEK [ ( valeur_index ( nom_colonne_index [ , … ] )) ]| FORCESCAN | HOLDLOCK | NOLOCK | NOWAIT | PAGLOCK | READCOMMITTED | READCOMMITTEDLOCK | READPAST | READUNCOMMITTED | REPEATABLEREAD | ROWLOCK | SERIALIZABLE | SNAPSHOT | SPATIAL_WINDOW_MAX_CELLS | TABLOCK | TABLOCKX | UPDLOCK | XLOCK } Indicateur de table à appliquer à la table ou à la vue correspondant à nom_objet_exposé comme indicateur de requête.<table_hint> ::= { [ NOEXPAND ] { INDEX ( index_value [ ,...n ] ) | INDEX = ( index_value ) | FORCESEEK [(index_value(index_column_name [,... ] )) ]| FORCESCAN | HOLDLOCK | NOLOCK | NOWAIT | PAGLOCK | READCOMMITTED | READCOMMITTEDLOCK | READPAST | READUNCOMMITTED | REPEATABLEREAD | ROWLOCK | SERIALIZABLE | SNAPSHOT | SPATIAL_WINDOW_MAX_CELLS | TABLOCK | TABLOCKX | UPDLOCK | XLOCK } Is the table hint to apply to the table or view that corresponds to exposed_object_name as a query hint. Pour obtenir une description de ces indicateurs, consultez Indicateurs de table (Transact-SQL).For a description of these hints, see Table Hints (Transact-SQL).

Les indicateurs de table autres que INDEX, FORCESCAN et FORCESEEK sont interdits comme indicateurs de requête, à moins que la requête n'ait déjà une clause WITH qui spécifie l'indicateur de table.Table hints other than INDEX, FORCESCAN, and FORCESEEK are disallowed as query hints unless the query already has a WITH clause specifying the table hint. Pour plus d'informations, consultez la section Notes.For more information, see Remarks.

Attention

Le fait de spécifier FORCESEEK avec des paramètres limite davantage le nombre de plans qui peuvent être considérés par l'optimiseur que le fait de spécifier FORCESEEK sans paramètre.Specifying FORCESEEK with parameters limits the number of plans that can be considered by the optimizer more than when specifying FORCESEEK without parameters. Cela peut provoquer une erreur « Impossible de générer le plan » dans davantage de cas.This may cause a "Plan cannot be generated" error to occur in more cases. Dans une version ultérieure, il se peut que des modifications internes de l'optimiseur autorisent la prise en considération de davantage de plans.In a future release, internal modifications to the optimizer may allow more plans to be considered.

NotesRemarks

Il n’est pas possible de spécifier des indicateurs de requête dans une instruction INSERT, sauf si celle-ci contient une clause SELECT.Query hints can't be specified in an INSERT statement, except when a SELECT clause is used inside the statement.

Les indicateurs de requête ne peuvent être spécifiés que dans une requête de niveau supérieur et non pas dans des sous-requêtes.Query hints can be specified only in the top-level query, not in subqueries. Lorsqu’un indicateur de table est spécifié comme indicateur de requête, il peut se trouver dans la requête de premier niveau ou dans une sous-requête.When a table hint is specified as a query hint, the hint can be specified in the top-level query or in a subquery. Toutefois, la valeur spécifiée pour nom_objet_exposé dans la clause TABLE HINT doit correspondre exactement au nom exposé dans la requête ou la sous-requête.However, the value specified for exposed_object_name in the TABLE HINT clause must match exactly the exposed name in the query or subquery.

Spécification d'indicateurs de table comme indicateurs de requêteSpecifying Table Hints as Query Hints

Nous vous recommandons d’utiliser l’indicateur de table INDEX, FORCESCAN ou FORCESEEK comme indicateur de requête uniquement dans le contexte d’un repère de plan.We recommend using the INDEX, FORCESCAN, or FORCESEEK table hint as a query hint only in the context of a plan guide. Les repères de plan sont utiles lorsqu’il n’est pas possible de modifier la requête d'origine, par exemple s’il s'agit d'une application tierce.Plan guides are useful when you can't modify the original query, for example, because it's a third-party application. L'indicateur de requête spécifié dans le repère de plan est ajouté à la requête avant sa compilation et son optimisation.The query hint specified in the plan guide is added to the query before it's compiled and optimized. Pour les requêtes ad hoc, utilisez la clause TABLE HINT uniquement lors du test des instructions de repère de plan.For ad-hoc queries, use the TABLE HINT clause only when testing plan guide statements. Pour toutes les autres requêtes ad hoc, nous recommandons de spécifier ces indicateurs uniquement comme indicateurs de table.For all other ad-hoc queries, we recommend specifying these hints only as table hints.

Lorsqu'ils sont spécifiés comme indicateurs de requête, les indicateurs de table INDEX, FORCESCAN et FORCESEEK sont valides pour les objets suivants :When specified as a query hint, the INDEX, FORCESCAN, and FORCESEEK table hints are valid for the following objects:

  • TablesTables
  • VuesViews
  • Vues indexéesIndexed views
  • Expressions de table communes (l'indicateur doit être spécifié dans l'instruction SELECT dont le jeu de résultats remplit l'expression de table commune)Common table expressions (the hint must be specified in the SELECT statement whose result set populates the common table expression)
  • Vues de gestion dynamiqueDynamic management views
  • Sous-requêtes nomméesNamed subqueries

Il est possible de spécifier des indicateurs de table INDEX, FORCESCAN et FORCESEEK comme indicateurs de requête pour une requête ne disposant pas d’indicateurs de table.You can specify INDEX, FORCESCAN, and FORCESEEK table hints as query hints for a query that doesn't have any existing table hints. Vous pouvez également les utiliser pour remplacer respectivement des indicateurs INDEX, FORCESCAN et FORCESEEK existants dans la requête.You can also use them to replace existing INDEX, FORCESCAN, or FORCESEEK hints in the query, respectively.

Les indicateurs de table autres que INDEX, FORCESCAN et FORCESEEK sont interdits comme indicateurs de requête, à moins que la requête n'ait déjà une clause WITH qui spécifie l'indicateur de table.Table hints other than INDEX, FORCESCAN, and FORCESEEK are disallowed as query hints unless the query already has a WITH clause specifying the table hint. Dans ce cas, il faut également spécifier un indicateur correspondant comme indicateur de requête.In this case, a matching hint must also be specified as a query hint. Utilisez pour cela TABLE HINT dans la clause OPTION.Specify the matching hint as a query hint by using TABLE HINT in the OPTION clause. Cette spécification préserve la sémantique de la requête.This specification preserves the query's semantics. Par exemple, si la requête contient l’indicateur de table NOLOCK, la clause OPTION dans le paramètre **@hints** du repère de plan doit également contenir l’indicateur NOLOCK.For example, if the query contains the table hint NOLOCK, the OPTION clause in the **@hints** parameter of the plan guide must also contain the NOLOCK hint. Voir l'exemple K.See Example K.

L’erreur 8072 se produit dans deux scénarios :Error 8072 occurs in a couple of scenarios. lorsqu’un indicateur de table autre que INDEX, FORCESCAN ou FORCESEEK est spécifié en utilisant TABLE HINT dans la clause OPTION sans indicateur de requête correspondantOne is when you specify a table hint other than INDEX, FORCESCAN, or FORCESEEK by using TABLE HINT in the OPTION clause without a matching query hint. et inversement.The second scenario is the other way around. Cette erreur indique que la clause OPTION risque d’entraîner une modification de la sémantique de la requête, et donc un échec de la requête.This error indicates the OPTION clause can cause the semantics of the query to change, and the query fails.

ExemplesExamples

A.A. Utilisation de MERGE JOINUsing MERGE JOIN

L’exemple suivant spécifie que MERGE JOIN exécute l’opération JOIN dans la requête.The following example specifies that MERGE JOIN runs the JOIN operation in the query. L'exemple utilise la base de données AdventureWorks2012AdventureWorks2012.The example uses the AdventureWorks2012AdventureWorks2012 database.

SELECT *   
FROM Sales.Customer AS c  
INNER JOIN Sales.CustomerAddress AS ca ON c.CustomerID = ca.CustomerID  
WHERE TerritoryID = 5  
OPTION (MERGE JOIN);  
GO    

B.B. Utilisation de OPTIMIZE FORUsing OPTIMIZE FOR

L’exemple suivant indique à l’optimiseur de requête d’utiliser la valeur 'Seattle' pour la variable locale @city_name, mais aussi d’utiliser des données statistiques pour déterminer la valeur de la variable locale @postal_code lors de l’optimisation de la requête.The following example instructs the query optimizer to use the value 'Seattle' for local variable @city_name and to use statistical data to determine the value for the local variable @postal_code when optimizing the query. L'exemple utilise la base de données AdventureWorks2012AdventureWorks2012.The example uses the AdventureWorks2012AdventureWorks2012 database.

DECLARE @city_name nvarchar(30);  
DECLARE @postal_code nvarchar(15);  
SET @city_name = 'Ascheim';  
SET @postal_code = 86171;  
SELECT * FROM Person.Address  
WHERE City = @city_name AND PostalCode = @postal_code  
OPTION ( OPTIMIZE FOR (@city_name = 'Seattle', @postal_code UNKNOWN) );  
GO  

C.C. Utilisation de MAXRECURSIONUsing MAXRECURSION

MAXRECURSION peut être utilisé pour empêcher une expression de table commune récursive mal rédigée d'entrer dans une boucle infinie.MAXRECURSION can be used to prevent a poorly formed recursive common table expression from entering into an infinite loop. L’exemple suivant créée intentionnellement une boucle infinie et utilise l’indicateur MAXRECURSION pour limiter le nombre de niveaux de récursivité à deux.The following example intentionally creates an infinite loop and uses the MAXRECURSION hint to limit the number of recursion levels to two. L'exemple utilise la base de données AdventureWorks2012AdventureWorks2012.The example uses the AdventureWorks2012AdventureWorks2012 database.

--Creates an infinite loop  
WITH cte (CustomerID, PersonID, StoreID) AS  
(  
    SELECT CustomerID, PersonID, StoreID  
    FROM Sales.Customer  
    WHERE PersonID IS NOT NULL  
  UNION ALL  
    SELECT cte.CustomerID, cte.PersonID, cte.StoreID  
    FROM cte   
    JOIN  Sales.Customer AS e   
        ON cte.PersonID = e.CustomerID  
)  
--Uses MAXRECURSION to limit the recursive levels to 2  
SELECT CustomerID, PersonID, StoreID  
FROM cte  
OPTION (MAXRECURSION 2);  
GO  

Une fois l'erreur de codage corrigée, MAXRECURSION n'est plus nécessaire.After the coding error is corrected, MAXRECURSION is no longer required.

D.D. Utilisation de MERGE UNIONUsing MERGE UNION

L’exemple suivant utilise l’indicateur de requête MERGE UNION.The following example uses the MERGE UNION query hint. L'exemple utilise la base de données AdventureWorks2012AdventureWorks2012.The example uses the AdventureWorks2012AdventureWorks2012 database.

SELECT *  
FROM HumanResources.Employee AS e1  
UNION  
SELECT *  
FROM HumanResources.Employee AS e2  
OPTION (MERGE UNION);  
GO  

E.E. Utilisation de HASH GROUP et de FASTUsing HASH GROUP and FAST

L’exemple suivant utilise les indicateurs de requête HASH GROUP et FAST.The following example uses the HASH GROUP and FAST query hints. L'exemple utilise la base de données AdventureWorks2012AdventureWorks2012.The example uses the AdventureWorks2012AdventureWorks2012 database.

SELECT ProductID, OrderQty, SUM(LineTotal) AS Total  
FROM Sales.SalesOrderDetail  
WHERE UnitPrice < $5.00  
GROUP BY ProductID, OrderQty  
ORDER BY ProductID, OrderQty  
OPTION (HASH GROUP, FAST 10);  
GO    

F.F. Utilisation de MAXDOPUsing MAXDOP

L’exemple suivant utilise l’indicateur de requête MAXDOP.The following example uses the MAXDOP query hint. L'exemple utilise la base de données AdventureWorks2012AdventureWorks2012.The example uses the AdventureWorks2012AdventureWorks2012 database.

S'applique à: SQL Server 2008SQL Server 2008 jusqu'à SQL Server 2017SQL Server 2017.Applies to: SQL Server 2008SQL Server 2008 through SQL Server 2017SQL Server 2017.

SELECT ProductID, OrderQty, SUM(LineTotal) AS Total  
FROM Sales.SalesOrderDetail  
WHERE UnitPrice < $5.00  
GROUP BY ProductID, OrderQty  
ORDER BY ProductID, OrderQty  
OPTION (MAXDOP 2);    
GO

G.G. Utilisation de INDEXUsing INDEX

Les exemples suivants utilisent l'indicateur INDEX.The following examples use the INDEX hint. Le premier exemple spécifie un index unique.The first example specifies a single index. Le deuxième exemple spécifie plusieurs index pour une référence de table individuelle.The second example specifies multiple indexes for a single table reference. Dans les deux exemples, étant donné que l'indicateur INDEX est appliqué à une table qui utilise un alias, la clause TABLE HINT doit également spécifier le même alias que le nom d'objet exposé.In both examples, because you apply the INDEX hint on a table that uses an alias, the TABLE HINT clause must also specify the same alias as the exposed object name. L'exemple utilise la base de données AdventureWorks2012AdventureWorks2012.The example uses the AdventureWorks2012AdventureWorks2012 database.

EXEC sp_create_plan_guide   
    @name = N'Guide1',   
    @stmt = N'SELECT c.LastName, c.FirstName, e.Title  
              FROM HumanResources.Employee AS e   
              JOIN Person.Contact AS c ON e.ContactID = c.ContactID  
              WHERE e.ManagerID = 2;',   
    @type = N'SQL',  
    @module_or_batch = NULL,   
    @params = NULL,   
    @hints = N'OPTION (TABLE HINT(e, INDEX (IX_Employee_ManagerID)))';  
GO  
EXEC sp_create_plan_guide   
    @name = N'Guide2',   
    @stmt = N'SELECT c.LastName, c.FirstName, e.Title  
              FROM HumanResources.Employee AS e  
              JOIN Person.Contact AS c ON e.ContactID = c.ContactID  
              WHERE e.ManagerID = 2;',   
    @type = N'SQL',  
    @module_or_batch = NULL,   
    @params = NULL,   
    @hints = N'OPTION (TABLE HINT(e, INDEX(PK_Employee_EmployeeID, IX_Employee_ManagerID)))';  
GO    

H.H. Utilisation de FORCESEEKUsing FORCESEEK

L'exemple suivant utilise l'indicateur de table FORCESEEK.The following example uses the FORCESEEK table hint. La clause TABLE HINT doit également spécifier le même nom en deux parties que le nom d’objet exposé.The TABLE HINT clause must also specify the same two-part name as the exposed object name. Indiquez ce nom lorsque vous appliquez l’indicateur INDEX à une table qui utilise un nom en deux parties.Specify the name when you apply the INDEX hint on a table that uses a two-part name. L'exemple utilise la base de données AdventureWorks2012AdventureWorks2012.The example uses the AdventureWorks2012AdventureWorks2012 database.

EXEC sp_create_plan_guide   
    @name = N'Guide3',   
    @stmt = N'SELECT c.LastName, c.FirstName, HumanResources.Employee.Title  
              FROM HumanResources.Employee  
              JOIN Person.Contact AS c ON HumanResources.Employee.ContactID = c.ContactID  
              WHERE HumanResources.Employee.ManagerID = 3  
              ORDER BY c.LastName, c.FirstName;',   
    @type = N'SQL',  
    @module_or_batch = NULL,   
    @params = NULL,   
    @hints = N'OPTION (TABLE HINT( HumanResources.Employee, FORCESEEK))';  
GO    

I.I. Utilisation de plusieurs indicateurs de tableUsing multiple table hints

L'exemple suivant applique l'indicateur INDEX à une table et l'indicateur FORCESEEK à une autre.The following example applies the INDEX hint to one table and the FORCESEEK hint to another. L'exemple utilise la base de données AdventureWorks2012AdventureWorks2012.The example uses the AdventureWorks2012AdventureWorks2012 database.

EXEC sp_create_plan_guide   
    @name = N'Guide4',   
    @stmt = N'SELECT e.ManagerID, c.LastName, c.FirstName, e.Title  
              FROM HumanResources.Employee AS e   
              JOIN Person.Contact AS c ON e.ContactID = c.ContactID  
              WHERE e.ManagerID = 3;',   
    @type = N'SQL',  
    @module_or_batch = NULL,   
    @params = NULL,   
    @hints = N'OPTION (TABLE HINT (e, INDEX( IX_Employee_ManagerID))   
                       , TABLE HINT (c, FORCESEEK))';  
GO  

J.J. Utilisation de TABLE HINT pour substituer un indicateur de table existantUsing TABLE HINT to override an existing table hint

L’exemple suivant montre comment se servir de l’indicateur TABLE HINT.The following example shows how to use the TABLE HINT hint. Vous pouvez l’utiliser sans spécifier d’indicateur pour remplacer le comportement de l’indicateur de table INDEX spécifié dans la clause FROM de la requête.You can use the hint without specifying a hint to override the INDEX table hint behavior you specify in the FROM clause of the query. L'exemple utilise la base de données AdventureWorks2012AdventureWorks2012.The example uses the AdventureWorks2012AdventureWorks2012 database.

EXEC sp_create_plan_guide   
    @name = N'Guide5',   
    @stmt = N'SELECT e.ManagerID, c.LastName, c.FirstName, e.Title  
              FROM HumanResources.Employee AS e WITH (INDEX (IX_Employee_ManagerID))  
              JOIN Person.Contact AS c ON e.ContactID = c.ContactID  
              WHERE e.ManagerID = 3;',   
    @type = N'SQL',  
    @module_or_batch = NULL,   
    @params = NULL,   
    @hints = N'OPTION (TABLE HINT(e))';  
GO    

K.K. Spécification d'indicateurs de table affectant la sémantiqueSpecifying semantics-affecting table hints

L’exemple suivant contient deux indicateurs de table dans la requête : NOLOCK, qui affecte la sémantique, et INDEX, qui n’affecte pas la sémantique.The following example contains two table hints in the query: NOLOCK, which is semantic-affecting, and INDEX, which is non-semantic-affecting. Pour préserver la sémantique de la requête, l'indicateur NOLOCK est spécifié dans la clause OPTIONS du repère de plan.To preserve the semantics of the query, the NOLOCK hint is specified in the OPTIONS clause of the plan guide. En parallèle de l'indicateur NOLOCK, spécifiez les indicateurs INDEX et FORCESEEK pour remplacer l'indicateur INDEX sans effet sur la sémantique dans la requête lors de la compilation et de l’optimisation de l'instruction.Along with the NOLOCK hint, specify the INDEX and FORCESEEK hints and replace the non-semantic-affecting INDEX hint in the query during statement compilation and optimization. L'exemple utilise la base de données AdventureWorks2012AdventureWorks2012.The example uses the AdventureWorks2012AdventureWorks2012 database.

EXEC sp_create_plan_guide   
    @name = N'Guide6',   
    @stmt = N'SELECT c.LastName, c.FirstName, e.Title  
              FROM HumanResources.Employee AS e   
                   WITH (NOLOCK, INDEX (PK_Employee_EmployeeID))  
              JOIN Person.Contact AS c ON e.ContactID = c.ContactID  
              WHERE e.ManagerID = 3;',  
    @type = N'SQL',  
    @module_or_batch = NULL,   
    @params = NULL,   
    @hints = N'OPTION (TABLE HINT (e, INDEX(IX_Employee_ManagerID), NOLOCK, FORCESEEK))';  
GO    

L'exemple suivant indique une autre méthode pour préserver la sémantique de la requête et permettre à l'optimiseur de choisir un index autre que l'index spécifié dans l'indicateur de table.The following example shows an alternative method to preserving the semantics of the query and allowing the optimizer to choose an index other than the index specified in the table hint. Autorisez l’optimiseur à choisir en spécifiant l’indicateur NOLOCK dans la clause OPTIONS.Allow the optimizer to choose by specifying the NOLOCK hint in the OPTIONS clause. En effet, cet indicateur affecte la sémantique.You specify the hint because it's semantic-affecting. Ensuite, indiquez le mot clé TABLE HINT avec seulement une référence de table, sans indicateur INDEX.Then, specify the TABLE HINT keyword with only a table reference and no INDEX hint. L'exemple utilise la base de données AdventureWorks2012AdventureWorks2012.The example uses the AdventureWorks2012AdventureWorks2012 database.

EXEC sp_create_plan_guide   
    @name = N'Guide7',   
    @stmt = N'SELECT c.LastName, c.FirstName, e.Title  
              FROM HumanResources.Employee AS e   
                   WITH (NOLOCK, INDEX (PK_Employee_EmployeeID))  
              JOIN Person.Contact AS c ON e.ContactID = c.ContactID  
              WHERE e.ManagerID = 2;',  
    @type = N'SQL',  
    @module_or_batch = NULL,   
    @params = NULL,   
    @hints = N'OPTION (TABLE HINT (e, NOLOCK))';  
GO  

L.L. Utilisation d’indicateurs USE HINTUsing USE HINT

L’exemple suivant utilise les indicateurs de requête RECOMPILE et USE HINT.The following example uses the RECOMPILE and USE HINT query hints. L'exemple utilise la base de données AdventureWorks2012AdventureWorks2012.The example uses the AdventureWorks2012AdventureWorks2012 database.

S’applique à : Azure SQL DatabaseAzure SQL Database, SQL Server 2016 (13.x)SQL Server 2016 (13.x).Applies to: Azure SQL DatabaseAzure SQL Database, SQL Server 2016 (13.x)SQL Server 2016 (13.x).

SELECT * FROM Person.Address  
WHERE City = 'SEATTLE' AND PostalCode = 98104
OPTION (RECOMPILE, USE HINT ('ASSUME_MIN_SELECTIVITY_FOR_FILTER_ESTIMATES', 'DISABLE_PARAMETER_SNIFFING')); 
GO  

Voir aussiSee Also

Indicateurs (Transact-SQL) Hints (Transact-SQL)
sp_create_plan_guide (Transact-SQL) sp_create_plan_guide (Transact-SQL)
sp_control_plan_guide (Transact-SQL)sp_control_plan_guide (Transact-SQL)
Indicateurs de trace Trace Flags
Conventions syntaxiques de Transact-SQLTransact-SQL Syntax Conventions