Catégories :

Fonctions de chaîne et fonctions binaires

COLLATE

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

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

Syntaxe

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

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

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

<string_expression> COLLATE '<collation_specification>'
Copy

Arguments

string_expression

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

collation_specification

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é collation_specification spécifiée à la place de la collation_specification 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 collation_specification 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 ('ñ');
Copy

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                          |
+---+--------------+------------------------+-----------------------------------+
Copy

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                         |
+---+--------------------------+--------------------------+------------------------+------------------------------+
Copy

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

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

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');
Copy
SELECT spanish_phrase FROM collation_demo 
  ORDER BY spanish_phrase COLLATE 'utf8';
Copy