Catégories :

Fonctions de chaîne et fonctions binaires

COLLATE

Renvoie une copie de la chaîne d’origine, mais avec la propriété spécification_classement spécifiée à la place de la propriété d’origine spécification_classement.

Cette copie peut être utilisée dans les comparaisons de chaînes suivantes, qui utiliseront la nouvelle spécification_classement.

Syntaxe

La fonction COLLATE peut être appelée comme une fonction normale :

COLLATE(<string_expression>, '<collation_specification>')

La fonction COLLATE peut être utilisée comme s’il s’agissait d’un opérateur INFIX :

<string_expression> COLLATE '<collation_specification>'

Arguments

expression_chaîne

La chaîne à partir de laquelle créer la copie.

spécification_classement

Ceci spécifie le classement à stocker avec la copie de la chaîne. Pour plus d’informations sur les spécificateurs de classement, voir Spécifications de classement.

Renvoie

Retourne une copie de la chaîne d’origine, mais avec la propriété spécification_classement spécifiée à la place de la spécification_classement d’origine.

Notes sur l’utilisation

Chaque VARCHAR contient une propriété qui contient le spécificateur de classement à utiliser lors de la comparaison de VARCHAR avec un autre VARCHAR. La fonction COLLATE copie la chaîne, mais place la nouvelle spécification de classement plutôt que la spécification d’origine dans la copie. La chaîne elle-même est inchangée ; seul le spécificateur de classement associé à la chaîne est modifié.

Lorsque COLLATE est utilisé en tant qu’opérateur infix, la spécification_classement doit être une chaîne constante et non une expression générale.

Exemples

L’exemple suivant montre que l’appel de la fonction COLLATE renvoie une copie de la chaîne avec une spécification de classement différente.

Créer la table et insérer une ligne. La spécification de classement de la valeur dans la ligne insérée est “sp” (espagnol).

CREATE TABLE collation1 (v VARCHAR COLLATE 'sp');
INSERT INTO collation1 (v) VALUES ('ñ');

Cela montre que la fonction COLLATE ne modifie pas la chaîne. La chaîne copiée dans la troisième colonne est en minuscules, tout comme la chaîne d’origine dans la première colonne qui est en minuscules. Cependant, la spécification de classement de la valeur renvoyée par COLLATE est passée de « sp » à « sp-upper » ; vous pouvez le voir dans la quatrième colonne.

SELECT v,
       COLLATION(v),
       COLLATE(v, 'sp-upper'),
       COLLATION(COLLATE(v, 'sp-upper'))
    FROM collation1;
+---+--------------+------------------------+-----------------------------------+
| V | COLLATION(V) | COLLATE(V, 'SP-UPPER') | COLLATION(COLLATE(V, 'SP-UPPER')) |
|---+--------------+------------------------+-----------------------------------|
| ñ | sp           | ñ                      | sp-upper                          |
+---+--------------+------------------------+-----------------------------------+

Cette requête montre que, bien que la valeur renvoyée par COLLATE soit toujours une chaîne en minuscules, le spécificateur de classement “supérieur” est utilisé lors de la comparaison de cette chaîne avec une autre chaîne :

SELECT v,
       v = 'ñ' AS "COMPARISON TO LOWER CASE",
       v = 'Ñ' AS "COMPARISON TO UPPER CASE",
       COLLATE(v, 'sp-upper'),
       COLLATE(v, 'sp-upper') = 'Ñ'
    FROM collation1;
+---+--------------------------+--------------------------+------------------------+------------------------------+
| V | COMPARISON TO LOWER CASE | COMPARISON TO UPPER CASE | COLLATE(V, 'SP-UPPER') | COLLATE(V, 'SP-UPPER') = 'Ñ' |
|---+--------------------------+--------------------------+------------------------+------------------------------|
| ñ | True                     | False                    | ñ                      | True                         |
+---+--------------------------+--------------------------+------------------------+------------------------------+

Cette commande trie les résultats à l’aide d’un classement en allemand (néerlandais).

SELECT *
    FROM table t1
    ORDER BY COLLATE(col1 , 'de');

Les deux requêtes suivantes renvoient le même résultat. Le premier utilise COLLATE en tant que fonction ; le second utilise COLLATE en tant qu’opérateur infix :

SELECT spanish_phrase FROM collation_demo 
  ORDER BY COLLATE(spanish_phrase, 'utf8');
SELECT spanish_phrase FROM collation_demo 
  ORDER BY spanish_phrase COLLATE 'utf8';