Priorité de classement (Transact-SQL)Collation Precedence (Transact-SQL)

CETTE RUBRIQUE S’APPLIQUE À :ouiSQL Server (à partir de la version 2008)ouiAzure SQL DatabaseouiAzure SQL Data Warehouse ouiParallel Data Warehouse THIS TOPIC APPLIES TO: yesSQL Server (starting with 2008)yesAzure SQL DatabaseyesAzure SQL Data Warehouse yesParallel Data Warehouse

La priorité de classement, également appelée règles de contraintes de classements, détermine :Collation precedence, also known as collation coercion rules, determines the following:

  • le classement du résultat final d'une expression évaluée en une chaîne de caractères ;The collation of the final result of an expression that is evaluated to a character string.

  • le classement utilisé par certains opérateurs, tels que LIKE et IN, qui utilisent des entrées de chaînes de caractères, mais ne renvoient pas une chaîne de caractères.The collation that is used by collation-sensitive operators that use character string inputs but do not return a character string, such as LIKE and IN.

    Les règles de priorité de classement s’appliquent uniquement aux types de données de chaînes de caractères : char, varchar, texte, nchar, nvarchar, et ntext.The collation precedence rules apply only to the character string data types: char, varchar, text, nchar, nvarchar, and ntext. Les objets comportant d'autres types de données n'interviennent pas dans les évaluations de classement.Objects that have other data types do not participate in collation evaluations.

Étiquettes de classementCollation Labels

Le tableau suivant répertorie et décrit les quatre catégories de classement des objets.The following table lists and describes the four categories in which the collations of all objects are identified. Le nom de chaque catégorie est identifié par une étiquette de classement.The name of each category is called the collation label.

Étiquette de classementCollation label Types d’objetsTypes of objects
Contrainte par défautCoercible-default Toute variable de chaîne de caractères Transact-SQLTransact-SQL, tout paramètre, littéral, résultat d'une fonction de catalogue intégrée, ou toute fonction intégrée qui ne prend pas les entrées de type chaîne, mais produit un résultat de type chaîne.Any Transact-SQLTransact-SQL character string variable, parameter, literal, or the output of a catalog built-in function, or a built-in function that does not take string inputs but produces a string output.

Si l'objet est déclaré dans une fonction définie par l'utilisateur, une procédure stockée ou un déclencheur, il se voit attribuer le classement par défaut de la base de données dans lequel la fonction, la procédure stockée ou le déclencheur est créé.If the object is declared in a user-defined function, stored procedure, or trigger, the object is assigned the default collation of the database in which the function, stored procedure, or trigger is created. Si l'objet est déclaré dans un traitement, le classement par défaut de la base de données actuelle lui est attribué pour la connexion.If the object is declared in a batch, the object is assigned the default collation of the current database for the connection.
X impliciteImplicit X Référence de colonne.A column reference. Le classement de l'expression (X) provient du classement défini pour la colonne dans la table ou la vue.The collation of the expression (X) is taken from the collation defined for the column in the table or view.

Même si la colonne est explicitement affectée à un classement par une clause COLLATE de l'instruction CREATE TABLE ou CREATE VIEW, la référence de la colonne est classée comme étant implicite.Even if the column was explicitly assigned a collation by using a COLLATE clause in the CREATE TABLE or CREATE VIEW statement, the column reference is classified as implicit.
X expliciteExplicit X Expression explicitement convertie en un classement spécifique (X) à l'aide d'une clause COLLATE dans l'expression.An expression that is explicitly cast to a specific collation (X) by using a COLLATE clause in the expression.
Sans classementNo-collation Indique que la valeur d'une expression est le résultat d'une opération entre deux chaînes dont l'étiquette de classement implicite génère des classements conflictuels.Indicates that the value of an expression is the result of an operation between two strings that have conflicting collations of the implicit collation label. Le résultat de l'expression est défini comme étant dépourvu d'un classement.The expression result is defined as not having a collation.

Règles de classementCollation Rules

L'étiquette de classement d'une expression simple qui fait référence à un seul objet de chaîne de caractère représente l'étiquette de classement de l'objet en référence.The collation label of a simple expression that references only one character string object is the collation label of the referenced object.

L'étiquette de classement d'une expression complexe qui fait référence à deux expressions d'opérandes dotées de la même étiquette de classement constitue l'étiquette de classement des expressions d'opérandes.The collation label of a complex expression that references two operand expressions with the same collation label is the collation label of the operand expressions.

L'étiquette de classement du résultat final d'une expression complexe qui fait référence à deux expressions d'opérandes comportant des classements différents obéit aux règles suivantes :The collation label of the final result of a complex expression that references two operand expressions with different collations is based on the following rules:

  • L'étiquette Explicite est prioritaire par rapport à l'étiquette Implicite.Explicit takes precedence over implicit. L'étiquette Implicite est prioritaire par rapport à l'étiquette Contrainte par défaut.Implicit takes precedence over Coercible-default:

    Explicite > Implicite > Contrainte par défautExplicit > Implicit > Coercible-default

  • La combinaison de deux expressions explicites affectées à des classements différents génère une erreur.Combining two Explicit expressions that have been assigned different collations generates an error:

    X explicite + Y explicite = ErreurExplicit X + Explicit Y = Error

  • La combinaison de deux expressions implicites affectées à des classements différents produit un résultat dépourvu de classement :Combining two Implicit expressions that have different collations yields a result of No-collation:

    X implicite + Y implicite = Sans classementImplicit X + Implicit Y = No-collation

  • La combinaison d'une expression sans classement avec une expression d'une étiquette, à l'exception d'un classement explicite (voir règle suivante), produit un résultat comportant l'étiquette Sans classement (No-collation) :Combining an expression with No-collation with an expression of any label, except Explicit collation (see the following rule), yields a result that has the No-collation label:

    Sans classement + autre classement = Sans classementNo-collation + anything = No-collation

  • La combinaison d'une expression sans classement avec une expression dotée d'un classement explicite produit une expression affectée d'une étiquette explicite :Combining an expression with No-collation with an expression that has an Explicit collation, yields an expression with an Explicit label:

    Sans classement + X explicite = ExpliciteNo-collation + Explicit X = Explicit

    Le tableau suivant récapitule les différentes règles.The following table summarizes the rules.

Étiquette de contrainte d'opérandeOperand coercion label X expliciteExplicit X X impliciteImplicit X Contrainte par défautCoercible-default Sans classementNo-collation
Y expliciteExplicit Y Génère une erreurGenerates Error Le résultat est Y expliciteResult is Explicit Y Le résultat est Y expliciteResult is Explicit Y Le résultat est Y expliciteResult is Explicit Y
Y impliciteImplicit Y Le résultat est X expliciteResult is Explicit X Le résultat est Sans classementResult is No-collation Le résultat est Y impliciteResult is Implicit Y Le résultat est Sans classementResult is No-collation
Contrainte par défautCoercible-default Le résultat est X expliciteResult is Explicit X Le résultat est X impliciteResult is Implicit X Le résultat est Contrainte par défautResult is Coercible-default Le résultat est Sans classementResult is No-collation
Sans classementNo-collation Le résultat est X expliciteResult is Explicit X Le résultat est Sans classementResult is No-collation Le résultat est Sans classementResult is No-collation Le résultat est Sans classementResult is No-collation

Les règles supplémentaires suivantes s'appliquent également à la priorité de classement :The following additional rules also apply to collation precedence:

  • Une expression explicite ne peut pas avoir plusieurs clauses COLLATE.You cannot have multiple COLLATE clauses on an expression that is already an explicit expression. Par exemple, la clause WHERE suivante n'est pas valide car une clause COLLATE est spécifiée pour une expression qui est déjà explicite :For example, the following WHERE clause is not valid because a COLLATE clause is specified for an expression that is already an explicit expression:

    WHERE ColumnA = ( 'abc' COLLATE French_CI_AS) COLLATE French_CS_AS

  • Pour les conversions de page de code texte types de données ne sont pas autorisés.Code page conversions for text data types are not allowed. Vous ne pouvez pas convertir un texte expression d’un classement à un autre s’ils ont les pages de codes différentes.You cannot cast a text expression from one collation to another if they have the different code pages. L'opérateur d'affectation ne peut pas attribuer de valeurs si le classement de l'opérande texte de droite utilise une page de codes différente de l'opérande texte de gauche.The assignment operator cannot assign values when the collation of the right text operand has a different code page than the left text operand.

    La priorité de classement est déterminée après la conversion du type de données.Collation precedence is determined after data type conversion. L'opérande qui détermine le classement résultant peut être différent de l'opérande qui fournit le type de données du résultat final.The operand from which the resulting collation is taken can be different from the operand that supplies the data type of the final result. Par exemple, étudiez le traitement ci-dessous :For example, consider the following batch:

CREATE TABLE TestTab  
   (PrimaryKey int PRIMARY KEY,  
    CharCol char(10) COLLATE French_CI_AS  
   )  

SELECT *  
FROM TestTab  
WHERE CharCol LIKE N'abc'  

Le type de données Unicode de l'expression simple N'abc' est prioritaire.The Unicode data type of the simple expression N'abc' has a higher data type precedence. Par conséquent, l'expression résultante a le type de données Unicode affecté à N'abc'.Therefore, the resulting expression has the Unicode data type assigned to N'abc'. Cependant, l'expression CharCol a l'étiquette de classement Implicite, alors que N'abc' est associé à une étiquette de contrainte inférieure de Contrainte par défaut.However, the expression CharCol has a collation label of Implicit, and N'abc' has a lower coercion label of Coercible-default. Le classement French_CI_AS de CharCol sera dès lors utilisé.Therefore, the collation that is used is the French_CI_AS collation of CharCol.

Exemples de règles de classementExamples of Collation Rules

Les exemples suivants illustrent le fonctionnement des règles de classement.The following examples show how the collation rules work. Pour exécuter les exemples, créez la table test suivante.To run the examples, create the following test table.

USE tempdb;  
GO  

CREATE TABLE TestTab (  
   id int,   
   GreekCol nvarchar(10) collate greek_ci_as,   
   LatinCol nvarchar(10) collate latin1_general_cs_as  
   )  
INSERT TestTab VALUES (1, N'A', N'a');  
GO  

Conflit et erreur de classementCollation Conflict and Error

Dans la requête suivante, le prédicat présente un conflit de classement et génère une erreur.The predicate in the following query has collation conflict and generates an error.

SELECT *   
FROM TestTab   
WHERE GreekCol = LatinCol;  

Voici l'ensemble des résultats.Here is the result set.

Msg 448, Level 16, State 9, Line 2  
Cannot resolve collation conflict between 'Latin1_General_CS_AS' and 'Greek_CI_AS' in equal to operation.  

Étiquettes Explicite et Étiquette impliciteExplicit Label vs. Implicit Label

Dans la requête suivante, le prédicat est analysé dans le classement greek_ci_as, car l'expression de droite comporte l'étiquette Explicite.The predicate in the following query is evaluated in collation greek_ci_as because the right expression has the Explicit label. Celle-ci est prioritaire par rapport à l'étiquette Implicite de l'expression de gauche.This takes precedence over the Implicit label of the left expression.

SELECT *   
FROM TestTab   
WHERE GreekCol = LatinCol COLLATE greek_ci_as;  

Voici l'ensemble des résultats.Here is the result set.

id          GreekCol             LatinCol  
----------- -------------------- --------------------  
          1 A                    a  

(1 row affected)  

Étiquette sans classementNo-Collation Labels

Dans les requêtes suivantes, les expressions CASE ont l'étiquette Sans classement. Elles ne peuvent donc pas apparaître dans la liste de sélection, ni être traitées par les opérateurs qui respectent le classement.The CASE expressions in the following queries have a No-collation label; therefore, they cannot appear in the select list or be operated on by collation-sensitive operators. Toutefois, les expressions peuvent être traitées par les opérateurs qui ne respectent pas le classement.However, the expressions can be operated on by collation-insensitive operators.

SELECT (CASE WHEN id > 10 THEN GreekCol ELSE LatinCol END)   
FROM TestTab;  

Voici l'ensemble des résultats.Here is the result set.

Msg 451, Level 16, State 1, Line 1  
Cannot resolve collation conflict for column 1 in SELECT statement.  
SELECT PATINDEX((CASE WHEN id > 10 THEN GreekCol ELSE LatinCol END), 'a')  
FROM TestTab;  

Voici l'ensemble des résultats.Here is the result set.

Msg 446, Level 16, State 9, Server LEIH2, Line 1  
Cannot resolve collation conflict for patindex operation.  
SELECT (CASE WHEN id > 10 THEN GreekCol ELSE LatinCol END) COLLATE Latin1_General_CI_AS   
FROM TestTab;  

Voici l'ensemble des résultats.Here is the result set.

--------------------  
a  

(1 row affected)  

Sensibilité au classementCollation Sensitive and Collation Insensitive

Les opérateurs et les fonctions respectent ou non le classement.Operators and functions are either collation sensitive or insensitive.

Respect du classementCollation sensitive
Le respect du classement signifie que la spécification d'un opérande sans classement génère une erreur de compilation.This means that specifying a No-collation operand is a compile-time error. Le résultat de l'expression ne peut être de type sans classement.The expression result cannot be No-collation.

Non-respect du classementCollation insensitive
Le non-respect du classement signifie que les opérandes et le résultat peuvent être sans classement.This means that the operands and result can be No-collation.

Opérateurs et classementOperators and Collation

Les opérateurs de comparaison et les opérateurs MAX, MIN, BETWEEN, LIKE et IN respectent le classement.The comparison operators, and the MAX, MIN, BETWEEN, LIKE, and IN operators, are collation sensitive. La chaîne utilisée par les opérateurs se voit attribuer l'étiquette de classement de l'opérande comportant le degré de priorité le plus élevé.The string used by the operators is assigned the collation label of the operand that has the higher precedence. L'opérateur UNION respecte également le classement, et tous les opérandes de chaînes et le résultat final se voient attribuer le classement de l'opérande doté du degré de priorité le plus élevé.The UNION operator is also collation sensitive, and all string operands and the final result is assigned the collation of the operand with the highest precedence. La priorité de classement des opérandes UNION et du résultat est évaluée par colonne.The collation precedence of the UNION operands and result are evaluated column by column.

L'opérateur d'affectation ne respecte pas le classement et l'expression de droite est affectée au classement de gauche.The assignment operator is collation insensitive and the right expression is cast to the left collation.

L'opérateur de concaténation de chaînes respecte le classement, les deux opérandes de chaînes et le résultat se voient attribuer l'étiquette de classement de l'opérande comportant la priorité de classement la plus élevée.The string concatenation operator is collation sensitive, the two string operands and the result are assigned the collation label of the operand with the highest collation precedence. Les opérateurs UNION ALL et CASE respectent également le classement, et tous les opérandes de chaînes et résultats finaux se voient attribuer l'étiquette de classement de l'opérande doté du degré de priorité le plus élevé.The UNION ALL and CASE operators are collation insensitive, and all string operands and the final results are assigned the collation label of the operand with the highest precedence. La priorité de classement des opérandes UNION ALL et du résultat est évaluée par colonne.The collation precedence of the UNION ALL operands and result are evaluated column by column.

Fonctions et classementFunctions and Collation

LES fonctions CAST, CONVERT et COLLATE sont respectent le classement pour char, varchar, et texte des types de données.THE CAST, CONVERT, and COLLATE functions are collation sensitive for char, varchar, and text data types. Si l'entrée et la sortie des fonctions CAST et CONVERT sont des chaînes de caractères, la chaîne résultante a l'étiquette de classement de la chaîne d'entrée.If the input and output of the CAST and CONVERT functions are character strings, the output string has the collation label of the input string. Si l'entrée n'est pas une chaîne de caractères, la chaîne résultante est une contrainte par défaut et se voit attribuer le classement de la base de données actuelle pour la connexion, ou de celle contenant la fonction définie par l'utilisateur, la procédure stockée ou le déclencheur dans lequel la fonction CAST ou CONVERT est référencée.If the input is not a character string, the output string is Coercible-default and assigned the collation of the current database for the connection, or the database that contains the user-defined function, stored procedure, or trigger in which the CAST or CONVERT is referenced.

Pour les fonctions intégrées qui renvoient une chaîne, mais qui n'acceptent pas une chaîne en entrée, la chaîne résultante est une contrainte par défaut et se voit attribuer le classement de la base de données actuelle ou celui de la base de données contenant la fonction définie par l'utilisateur, la procédure stockée ou le déclencheur dans lequel la fonction est référencée.For the built-in functions that return a string but do not take a string input, the result string is Coercible-default and is assigned either the collation of the current database, or the collation of the database that contains the user-defined function, stored procedure, or trigger in which the function is referenced.

Les fonctions suivantes respectent le classement et leurs chaînes résultantes ont l'étiquette de classement de la chaîne d'entrée :The following functions are collation-sensitive and their output strings have the collation label of the input string:

CHARINDEXCHARINDEX REPLACEREPLACE
DIFFERENCEDIFFERENCE REVERSEREVERSE
ISNUMERICISNUMERIC RIGHTRIGHT
LEFTLEFT SOUNDEXSOUNDEX
LENLEN STUFFSTUFF
LOWERLOWER SUBSTRINGSUBSTRING
PATINDEXPATINDEX UPPERUPPER

Voir aussiSee Also

COLLATE (Transact-SQL) COLLATE (Transact-SQL)
Conversion de Type de données ( moteur de base de données ) Data Type Conversion (Database Engine)
Opérateurs ( Transact-SQL ) Operators (Transact-SQL)
Expressions (Transact-SQL)Expressions (Transact-SQL)