13. Interclassements (collations)

Un interclassement (collation) fixe la manière dont deux textes se comparent : égalité, ordre, GROUP BY, DISTINCT, clés PRIMARY / UNIQUE, jointures, LIKE, partitions et plein texte. MIRAJ en propose cinq, choisis par colonne, par table ou par expression, avec les règles de la référence. Tout texte est rangé en UTF-8 (utf8mb4).

13.1 Les interclassements#

Interclassement	Noms SQL acceptés	Comportement
général (par défaut)	`utf8mb4_general_ci`, `utf8mb3_general_ci` (`utf8_general_ci`), `latin1_swedish_ci`, `latin1_general_ci`	un poids de 16 bits par caractère ; casse et accents ignorés (`'Crème' = 'creme'`), `ß` = `s` (mais ≠ `ss`), `æ`, `œ`, `ø`, `ł` gardent leur propre poids ; tout caractère hors BMP pèse `U+FFFD` (`'😀' = '😁'`)
Unicode	`utf8mb4_unicode_ci`, `utf8mb3_unicode_ci` (`utf8_unicode_ci`)	table UCA 4.0.0 relevée sur la référence, niveau primaire seul : casse et accents ignorés, expansions (`'ß' = 'ss'`, `'œ' = 'oe'`, `'ﬁ' = 'fi'`, `'Ⅳ' = 'iv'`), marques combinantes et caractères de contrôle ignorés (`'e' + U+0301 = 'e'`), `æ` reste une lettre propre (`'æ' ≠ 'ae'`) ; ordre UCA (ponctuation < chiffres < lettres : `'_' < 'a'`) ; idéogrammes et caractères absents de la table : poids implicites ; tout caractère hors BMP a un même poids (`'😀' = '😁'`)
Unicode 5.2	`utf8mb4_unicode_520_ci`, `utf8mb3_unicode_520_ci` (`utf8_unicode_520_ci`)	table UCA 5.2.0 relevée sur la référence pour tout Unicode : mêmes règles, poids propres hors BMP (`'😀' ≠ '😁'`), espace de poids `020A`
Unicode 14	`utf8mb4_uca1400_ai_ci`, `utf8mb3_uca1400_ai_ci`	table UCA 14.0.0 relevée sur la référence pour tout Unicode, insensible aux accents et à la casse : `'æ' = 'ae'`, `'ø' = 'o'`, `'ł' = 'l'`, poids propres hors BMP, et contractions (939 suites de deux ou trois caractères pesées comme un tout : `И` + brève = `Й`, `L·` = `l`, voyelles antéposées thaïes et laotiennes : `'เก'` pèse `ก` puis `เ`)
binaire	`utf8mb4_bin`, `utf8mb3_bin` (`utf8_bin`), `latin1_bin`	comparaison par point de code : casse et accents distingués (`'A1' ≠ 'a1'`, `'é' ≠ 'e'`), `'B' < 'a'`

SELECT 'ß' = 'ss' COLLATE utf8mb4_general_ci     AS general,
       'ß' = 'ss' COLLATE utf8mb4_unicode_ci     AS unicode,
       '😀' = '😁' COLLATE utf8mb4_unicode_520_ci AS unicode_520,
       'æ' = 'ae' COLLATE utf8mb4_uca1400_ai_ci  AS uca1400,
       'é' = 'e'  COLLATE utf8mb4_bin            AS bin;

+---------+---------+-------------+---------+-----+
| general | unicode | unicode_520 | uca1400 | bin |
+---------+---------+-------------+---------+-----+
|       0 |       1 |           0 |       1 |   0 |
+---------+---------+-------------+---------+-----+

Tous sont PAD SPACE : les espaces finaux (U+0020 seulement) sont ignorés par =, l'ordre, GROUP BY, DISTINCT, les clés et les jointures ('a' = 'a ' vaut 1, même en binaire ; une tabulation finale compte). LIKE ne complète jamais par des espaces ('a ' LIKE 'a' est faux).

Les alias utf8_… sont lus utf8mb3_…. CHARACTER SET latin1 est accepté pour une colonne mais le texte reste rangé en utf8mb4. Le type binaire (BINARY, VARBINARY, BLOB, CAST(… AS BINARY)) se compare toujours octet par octet, sans PAD.

Une colonne JSON est un LONGTEXT en utf8mb4_bin muni de la contrainte implicite CHECK (json_valid(col)) : deux documents qui ne diffèrent que par la casse sont différents, et JSON_UNQUOTE(JSON_EXTRACT(doc, '$.a')) = 'x' ne trouve pas "X". SHOW CREATE TABLE l'écrit sous cette forme :

  `j` longtext CHARACTER SET utf8mb4 COLLATE utf8mb4_bin DEFAULT NULL CHECK (json_valid(`j`))

13.2 Choisir l'interclassement#

Colonne et table#

CREATE TABLE liasse (
    code   VARCHAR(10) COLLATE utf8mb4_bin PRIMARY KEY,   -- 'A1' et 'a1' sont deux codes
    nom    VARCHAR(80) CHARACTER SET utf8mb4 COLLATE utf8mb4_unicode_ci,
    notes  TEXT                                           -- défaut de la table
) DEFAULT CHARSET=utf8mb4 COLLATE=utf8mb4_general_ci;

[CHARACTER SET jeu] COLLATE nom après le type d'une colonne texte (CHAR, VARCHAR, *TEXT, ENUM, SET) ; CHARACTER SET jeu seul donne l'interclassement par défaut du jeu, l'interclassement général.
L'attribut BINARY d'une colonne texte (VARCHAR(10) BINARY) vaut COLLATE utf8mb4_bin ; BINARY COLLATE d'un autre nom : erreur 1302.
[DEFAULT] CHARSET = jeu, [DEFAULT] COLLATE = nom en option de table : défaut des colonnes texte écrites sans interclassement.
Exemple, avec les lignes ('A1', 'Straße') et ('a1', 'Dupont') : WHERE code = 'a1' ne rend que a1, WHERE nom = 'strasse' rend A1, et SHOW CREATE TABLE liasse écrit `code` varchar(10) CHARACTER SET utf8mb4 COLLATE utf8mb4_bin NOT NULL et `nom` varchar(80) CHARACTER SET utf8mb4 COLLATE utf8mb4_unicode_ci DEFAULT NULL ; SHOW FULL COLUMNS FROM liasse montre utf8mb4_bin, utf8mb4_unicode_ci et utf8mb4_general_ci dans la colonne Collation. Passer ensuite code en utf8mb4_general_ci rend Duplicate entry 'a1' for key 'PRIMARY' (1062).
CREATE TABLE … LIKE recopie colonnes et défaut ; CREATE TABLE … AS SELECT et les colonnes de vue prennent l'interclassement de la colonne source ou de l'expression (CONCAT(col_bin, 'x') reste binaire).

Base#

CREATE DATABASE compta CHARACTER SET utf8mb4 COLLATE utf8mb4_unicode_ci;
SHOW CREATE DATABASE compta;

+----------+-----------------------------------------------------------------------------------------------+
| Database | Create Database                                                                               |
+----------+-----------------------------------------------------------------------------------------------+
| compta   | CREATE DATABASE `compta` /*!40100 DEFAULT CHARACTER SET utf8mb4 COLLATE utf8mb4_unicode_ci */ |
+----------+-----------------------------------------------------------------------------------------------+

USE compta;
CREATE TABLE t (n VARCHAR(10));
-- SHOW CREATE TABLE t : … ) DEFAULT CHARSET=utf8mb4 COLLATE=utf8mb4_unicode_ci
ALTER DATABASE compta COLLATE utf8mb4_bin;      -- tables créées ensuite seulement
CREATE TABLE t2 (n VARCHAR(10));
-- SHOW CREATE TABLE t2 : … ) DEFAULT CHARSET=utf8mb4 COLLATE=utf8mb4_bin

CREATE DATABASE … [DEFAULT] [CHARACTER SET jeu] [DEFAULT] COLLATE nom fixe l'interclassement par défaut de la base : une table créée ensuite sans COLLATE= le prend, ainsi que ses colonnes texte écrites sans interclassement (une table temporaire aussi). CHARACTER SET utf8mb4 seul donne l'interclassement général.
ALTER {DATABASE | SCHEMA} [nom] [DEFAULT] [CHARACTER SET jeu] [DEFAULT] COLLATE nom le change pour les tables créées ensuite ; les tables existantes gardent le leur. Sans nom : la base courante (1046 sans base courante ; une base inconnue rend l'erreur 1, Can't create/write to file './inconnue/db.opt'). COMMENT est accepté et ignoré ; UPGRADE DATA DIRECTORY NAME : 1235.
Le défaut est gardé avec la base (fichier options.mro de son répertoire, absent pour l'interclassement général), repris par les sauvegardes et, en édition Cluster, par les secondaires.

`ALTER TABLE`#

MODIFY / CHANGE / ADD d'une colonne : COLLATE écrit, sinon le défaut de la table ; RENAME COLUMN garde l'interclassement.
[DEFAULT] COLLATE = nom change le défaut de la table sans toucher aux colonnes existantes ; [DEFAULT] CHARSET = jeu seul le remet à l'interclassement par défaut du jeu (général pour utf8mb4, utf8mb3 et latin1 ; CHARSET binary est sans effet). Seules (avec COMMENT ou RENAME), ces options changent le schéma sans recopier les lignes.
CONVERT TO CHARACTER SET utf8mb4 [COLLATE nom] convertit toutes les colonnes texte, JSON compris : après CONVERT TO CHARACTER SET utf8mb4 COLLATE utf8mb4_unicode_ci, SHOW CREATE TABLE écrit `j` longtext DEFAULT NULL CHECK (json_valid(`j`)) (interclassement de la table).
Changer l'interclassement d'une colonne de clé recontrôle la clé : des valeurs devenues égales ('A1' et 'a1' passant de binaire à général, 'ß' et 'ss' passant à Unicode) donnent 1062 et la table reste inchangée.
Changer l'interclassement d'une colonne de partitionnement est refusé (1235).

Expression#

expr COLLATE nom impose un interclassement à une expression texte :

SELECT 'a' COLLATE utf8mb4_bin = 'A';                    -- 0
SELECT * FROM clients WHERE nom = 'strasse' COLLATE utf8mb4_unicode_ci;   -- trouve « Straße »
SELECT code FROM liasse ORDER BY code COLLATE utf8mb4_general_ci;

Le nom doit être un interclassement de utf8mb4 ('a' COLLATE utf8_bin ou COLLATE latin1_bin : 1253) ; COLLATE binary : 1064. Deux exceptions, pour les applications écrites pour des bases anciennes : appliqué directement à une colonne, le nom peut être celui d'un autre jeu (nom COLLATE utf8mb3_general_ci est accepté et compare comme l'interclassement correspondant) ; après CONVERT(x USING jeu), il est contrôlé contre le jeu écrit (CONVERT(x USING utf8mb3) COLLATE utf8mb3_general_ci est accepté).

Connexion#

Un littéral texte ('abc') prend l'interclassement de la connexion, @@collation_connection (coercibilité COERCIBLE : une colonne l'emporte toujours sur lui) :

SET NAMES utf8mb4 COLLATE utf8mb4_bin;
SELECT 'a' = 'A';                                      -- 0
SELECT * FROM clients WHERE nom = 'DUPONT';            -- interclassement de la colonne nom
SET NAMES utf8mb4;                                     -- retour à utf8mb4_general_ci

SET NAMES jeu COLLATE nom, SET collation_connection = nom (ou DEFAULT) changent l'interclassement des littéraux des instructions suivantes de la session ; SET NAMES jeu seul et SET character_set_connection = jeu remettent l'interclassement général, SET CHARACTER SET jeu celui de la base courante (@@collation_database). SET GLOBAL collation_connection est sans effet.
Interclassement d'un autre jeu dans SET NAMES : 1253. Nom inconnu du moteur mais préfixé d'un jeu reconnu (par exemple utf8mb4_0900_ai_ci, envoyé d'office par certains connecteurs) : accepté, interclassement général (SET collation_connection ajoute l'avertissement 1273). Nom qui ne se rattache à aucun jeu reconnu (SET NAMES utf8mb4 COLLATE klingon_ci, SET collation_connection | collation_server | collation_database = 'klingon_ci') : erreur 1273.
Jeu de caractères inconnu dans SET NAMES, SET CHARACTER SET (SET CHARSET) ou SET character_set_client | _results | _connection | _server | _database : erreur 1115 (SET NAMES klingon). NULL n'est admis que pour character_set_results (ailleurs : 1231).
L'interclassement est résolu à la compilation de l'instruction, sans coût par ligne. Il ne s'applique pas aux expressions rangées avec une table (valeur par défaut, colonne générée, CHECK, partitionnement) ni au corps des événements : leurs littéraux restent en interclassement général, quelle que soit la session qui les exécute.
Objets gardés : comme la référence, une procédure, une fonction, un déclencheur ou une vue garde l'interclassement de la connexion de la session qui l'a créé. Les littéraux de son corps (ou de sa requête) y restent, quelle que soit la session qui l'appelle ou la lit, et même après un redémarrage. Une vue créée sous SET NAMES utf8mb4 COLLATE utf8mb4_bin compare 'a' = 'A' en binaire pour tout lecteur ; son résultat gardé (vue ordinaire ou CACHED, REFRESH VIEW) vaut pour toutes les sessions. L'interclassement figé se lit dans la colonne collation_connection de SHOW CREATE PROCEDURE | FUNCTION | TRIGGER | VIEW, de SHOW PROCEDURE | FUNCTION STATUS, SHOW TRIGGERS et d'information_schema.ROUTINES, TRIGGERS et VIEWS (COLLATION_CONNECTION). Un objet créé avant cette version vaut utf8mb4_general_ci.
Une variable utilisateur affectée d'un littéral garde l'interclassement de la connexion au moment de l'affectation (§ 13.3).
Les paramètres ? d'une requête préparée (protocole binaire, EXECUTE … USING) prennent, comme un littéral, l'interclassement de la connexion au moment de l'exécution (coercibles) : après SET NAMES utf8mb4 COLLATE utf8mb4_bin, ? = 'A' vaut 0 pour 'a', même pour une requête préparée avant le SET NAMES.
Une fonction qui rend un texte sans le tirer d'un argument texte (HEX, MD5, DATE_FORMAT, FORMAT, CONCAT(1, 2), LPAD(1, 3, 0)…) le rend sous l'interclassement de la connexion, coercible ; dans une expression rangée avec une table ou une routine, sous l'interclassement général.
La session commence sous l'interclassement annoncé par le client à la connexion (numéro de la poignée de main) : 45 utf8mb4_general_ci, 46 utf8mb4_bin, 224 utf8mb4_unicode_ci, 246 utf8mb4_unicode_520_ci. Tout autre numéro — 33 (utf8mb3), 255 (utf8mb4_0900_ai_ci, annoncé d'office par les connecteurs récents), numéro inconnu — laisse utf8mb4_general_ci.

13.3 Coercibilité : quel interclassement l'emporte#

Quand deux textes se rencontrent (=, <, IN, BETWEEN, CASE, LIKE, STRCMP, LOCATE, jointure, UNION, CONCAT…), chacun porte une coercibilité ; la plus faible l'emporte :

Coercibilité	Valeur	Exemples
`EXPLICIT`	0	`expr COLLATE nom`
`NONE`	1	réservé (MIRAJ ne le produit plus, voir ci-dessous)
`IMPLICIT`	2	colonne de table, de vue, de table dérivée ; `NEW.col` / `OLD.col` d'un déclencheur, variable ou paramètre de routine déclaré sous un interclassement Unicode ou binaire
`SYSCONST`	3	`USER()`, `DATABASE()`, `VERSION()`, `@@variable`
`CAST`	4	`CAST(… AS CHAR)`, `CONVERT(… USING utf8mb4)`
`USERVAR`	5	`@v` (sous l'interclassement de la valeur affectée)
`COERCIBLE`	6	littéral, paramètre du client, fonction sans argument texte (`HEX`, `DATE_FORMAT`) ; `NEW.col` d'une colonne générale, variable de routine générale
`NUMERIC` / `IGNORABLE`	7 / 8	nombres, dates, `NULL` : ne prennent pas part

Colonne contre littéral : la colonne l'emporte (WHERE code = 'a1' sur une colonne binaire ne rend pas 'A1') ; un COLLATE explicite l'emporte sur la colonne.
À coercibilité égale et interclassements différents, le plus large l'emporte : Unicode, puis général, puis binaire. Colonne binaire contre colonne générale : comparaison générale ; colonne générale contre colonne Unicode : comparaison Unicode ; 'a' COLLATE utf8mb4_bin = 'A' COLLATE utf8mb4_general_ci vaut 1.
La règle vaut pour tout nombre d'opérandes (u IN (g, 'x'), CASE, BETWEEN, UNION), pour les fonctions (CONCAT(u, g) est Unicode implicite) et pour les jointures.

Écarts voulus avec la référence : MIRAJ ne lève jamais 1267, 1270 ni 1271, et une colonne binaire ne l'emporte plus sur une colonne générale ou Unicode (la référence y compare en binaire). Une base dont les tables ont été créées sous des défauts différents (utf8mb3_uca1400_ai_ci d'un côté, utf8mb3_general_ci de l'autre) compare ses colonnes sans erreur, en Unicode. Un index ne sert cette comparaison que du côté de la colonne déjà en Unicode (§ 13.5).

Variables, déclencheurs et routines#

Variable utilisateur : @v garde l'interclassement de la valeur qu'on lui affecte (SET @v = x COLLATE utf8mb4_bin, SELECT col INTO @v, SELECT @v := col, SET @v = … dans une routine), coercibilité USERVAR : elle l'emporte sur un littéral (@v = 'a1' compare en binaire), pas sur une colonne. Une nouvelle affectation sans COLLATE reprend l'interclassement de la valeur : celui de la connexion pour un littéral (SET NAMES … COLLATE), général par défaut.
Déclencheur : NEW.col et OLD.col gardent l'interclassement de la colonne. Sur une colonne binaire, IF NEW.code = 'a1' est faux pour 'A1' ; sur une colonne Unicode, NEW.nom = 'ss' est vrai pour 'ß'. COLLATION(NEW.code) rend utf8mb4_bin, COERCIBILITY(NEW.code) 2.
Routine : un paramètre, une variable (DECLARE v VARCHAR(20) COLLATE utf8mb4_unicode_ci) ou le résultat d'une fonction (RETURNS VARCHAR(20) COLLATE utf8mb4_bin) gardent l'interclassement déclaré ; l'attribut BINARY vaut utf8mb4_bin. Un nom d'interclassement que MIRAJ ne connaît pas y reste accepté sans effet (une routine enregistrée se relit toujours).
Sans COLLATE : un paramètre, une variable (de routine ou de déclencheur) ou le résultat d'une fonction prend l'interclassement par défaut de la base au moment du CREATE, gardé avec l'objet : dans une base utf8mb4_unicode_ci, DECLARE v VARCHAR(10) DEFAULT 'ß' puis v = 'ss' est vrai, même après un ALTER DATABASE … COLLATE utf8mb4_general_ci (seules les routines créées ensuite prennent le nouveau défaut). La colonne Database Collation de SHOW CREATE et information_schema.ROUTINES.DATABASE_COLLATION montrent ce défaut figé ; SHOW CREATE PROCEDURE rend le texte tel qu'écrit, sans COLLATE ajouté. information_schema.PARAMETERS.COLLATION_NAME donne l'interclassement de chaque paramètre et du résultat.
Écart voulu : NEW.col d'une colonne générale et une variable de routine sans COLLATE (ou générale) restent coercibles (COERCIBILITY rend 6 et non 2). Contre une colonne binaire, la colonne l'emporte alors, comme sur la référence où le binaire gagne à coercibilité égale ; deux implicites prendraient ici le plus large (le général). Le chemin courant, tout en général, est inchangé.

13.4 Fonctions et opérateurs#

Opération	Interclassement appliqué
`=`, `<`, `<=>`, `IN`, `BETWEEN`, `CASE`, `NULLIF`, `LEAST`, `GREATEST`, `STRCMP`, `FIELD`, `FIND_IN_SET`	interclassement résolu des opérandes
`GROUP BY`, `DISTINCT`, `COUNT(DISTINCT)`, `MIN` / `MAX`, `ORDER BY`, fenêtres, jointures, `UNION`	celui de l'expression
`LIKE`	résolu sur la valeur et le motif ; caractère contre caractère, sans PAD et sans expansion (`'ß' LIKE 'ss'` est faux en Unicode, `'Crème' LIKE 'Cr_me'` vrai partout, `LIKE 'crème'` faux en binaire)
`LOCATE`, `INSTR`, `POSITION`	fenêtre de même longueur en octets que la sous-chaîne, comparée sous l'interclassement (`LOCATE('ss', 'Straße' COLLATE utf8mb4_unicode_ci)` rend 5, `LOCATE('a', 'A' COLLATE utf8mb4_bin)` rend 0 ; en général `LOCATE('ä', 'xá')` rend 2 et `LOCATE('e', 'é')` 0)
`REGEXP`, `REGEXP_*`	pas de poids (`'é' REGEXP 'e'` faux) ; insensible à la casse sauf en binaire (`'ABC' COLLATE utf8mb4_bin REGEXP 'abc'` vaut 0) ; le type de correspondance `'c'` / `'i'` l'emporte
`REPLACE`, `TRIM`, `SUBSTRING_INDEX`	recherche binaire (sensible à la casse) dans les trois cas
`WEIGHT_STRING`	celui du premier argument : général 16 bits par caractère, Unicode 16 bits par unité de poids (`AS CHAR(n)` coupe à n unités, complète par `0209`), binaire 3 octets par caractère (complété par `000020`)
`JSON_SEARCH`	celui du document (colonne `JSON` : binaire ; littéral : général ; colonne texte : la sienne)
`JSON_UNQUOTE`, `->>`	résultat toujours `utf8mb4_bin`, coercibilité `CAST` (4), quel que soit l'argument : `JSON_UNQUOTE('"a"') = 'A'` vaut 0 ; contre une colonne, la colonne l'emporte
`JSON_EXTRACT`, `->`, `JSON_VALUE`, `JSON_QUERY`	celui de leurs arguments (document d'abord)
`MATCH … AGAINST`	celui de l'index `FULLTEXT` : `'strasse'` trouve `Straße` en Unicode, le binaire distingue casse et accents

UPPER et LOWER restent des correspondances de casse Unicode quel que soit l'interclassement.

13.5 Index, clés et partitions#

Clés primaires et UNIQUE, index secondaires, clés étrangères, index trigramme et FULLTEXT, bornes et listes de partitions suivent l'interclassement de leur colonne : en binaire 'A1' et 'a1' sont deux clés, en Unicode 'ß' et 'ss' n'en font qu'une (1062). Un index ne sert une condition que si l'interclassement résolu de la condition est celui de la colonne : WHERE code COLLATE utf8mb4_general_ci = 'a1' lit toute la table. Un FULLTEXT sur des colonnes d'interclassements différents : 1283.

13.6 Métadonnées#

SHOW CREATE TABLE écrit CHARACTER SET utf8mb4 COLLATE nom après le type d'une colonne dont l'interclassement diffère du défaut de la table, et DEFAULT CHARSET=utf8mb4 COLLATE=nom quand le défaut de la table n'est pas l'interclassement général ou n'est pas celui de la base.
SHOW CREATE DATABASE ajoute /*!40100 DEFAULT CHARACTER SET utf8mb4 COLLATE nom */ quand le défaut de la base n'est pas l'interclassement général ; information_schema.SCHEMATA (DEFAULT_COLLATION_NAME) ; @@collation_database (relevé par USE), @@collation_connection.
SHOW FULL COLUMNS (colonne Collation), information_schema.COLUMNS.COLLATION_NAME, TABLES.TABLE_COLLATION.
SHOW COLLATION et information_schema.COLLATIONS : chaque nom accepté par COLLATE, avec le numéro, le jeu et le Sortlen de la référence, tous PAD SPACE : latin1_swedish_ci (8, défaut), latin1_bin (47), latin1_general_ci (48), utf8mb3_general_ci (33, défaut), utf8mb3_bin (83), utf8mb3_unicode_ci (192), utf8mb3_unicode_520_ci (214), utf8mb4_general_ci (45, défaut), utf8mb4_bin (46), utf8mb4_unicode_ci (224), utf8mb4_unicode_520_ci (246) ; Sortlen 8 pour les unicode, 1 pour les autres. utf8mb4_uca1400_ai_ci (2304) et utf8mb3_uca1400_ai_ci (2048) ne figurent que dans COLLATION_CHARACTER_SET_APPLICABILITY, comme sur la référence (qui y écrit uca1400_ai_ci dans COLLATION_NAME ; MIRAJ le nom complet). Les alias utf8_… sont listés sous leur nom utf8mb3_…. Chaque nom est rangé sous l'un des cinq interclassements du moteur (§ 13.1).
SHOW CHARACTER SET et information_schema.CHARACTER_SETS : latin1 (cp1252 West European, 1), utf8mb3 (3) et utf8mb4 (4), défaut général ; latin1 et utf8mb3 sont acceptés mais rangés en utf8mb4 (§ 13.8).
La référence 12.2 ne marque plus utf8mb4_general_ci ni utf8mb3_general_ci comme défaut de leur jeu (son défaut est uca1400_ai_ci) ; MIRAJ, dont c'est le défaut, les marque.
Protocole : une colonne de résultat Unicode ou binaire est annoncée 224 ou 46 ; une colonne générale, comme une colonne JSON, reste annoncée 33.

13.7 Erreurs#

Code	Cas
1062	doublon sous l'interclassement de la clé (aussi à l'`ALTER` qui change l'interclassement)
1064	`COLLATE binary` sur un texte
1235	changer l'interclassement d'une colonne de partitionnement ; `ALTER DATABASE … UPGRADE DATA DIRECTORY NAME`
1253	interclassement d'un autre jeu (`CHARACTER SET latin1 COLLATE utf8mb4_unicode_ci`, `'a' COLLATE utf8_bin`)
1273	nom inconnu : `Unknown collation: 'utf8mb4_0900_ai_ci'`
1283	`FULLTEXT` sur des colonnes d'interclassements différents
1302	`BINARY` et un `COLLATE` autre que binaire sur la même colonne

13.8 Écarts et hors périmètre#

Comparer unicode_ci à unicode_520_ci (ou à uca1400_ai_ci) donne 1267 sur la référence ; MIRAJ compare sous la table la plus récente, sans erreur.
Une table créée avant le 17/10/2026 sous unicode_520_ci ou uca1400_ai_ci avait été rangée sous unicode_ci : elle le reste (son fichier ne garde que unicode), et SHOW CREATE TABLE l'écrit ainsi ; ses index restent valides. ALTER TABLE … CONVERT TO CHARACTER SET utf8mb4 COLLATE … la passe sous la table voulue.
LIKE 'préfixe%' sous uca1400_ai_ci par un index : la référence calcule l'intervalle sans tenir compte des contractions et perd des lignes ('И' + brève LIKE 'И%') ; MIRAJ rend toujours le résultat de l'évaluation ligne à ligne.
Mélanges sans vainqueur : la référence lève 1267 / 1270 / 1271, MIRAJ compare sous le plus large (§ 13.3).
CHARACTER SET utf8mb4 seul, SET NAMES utf8mb4 sans COLLATE, CONVERT(… USING utf8mb4), l'introducteur _utf8mb4 et la poignée de main d'un client qui annonce 45 donnent l'interclassement général ; la référence 12.x y met uca1400_ai_ci (variable character_set_collations), si bien que sur elle même un serveur lancé avec --collation-server=utf8mb4_general_ci compare les littéraux d'une connexion sous uca1400_ai_ci. Les tables UCA 14 étant désormais exactes, ce défaut est un choix gardé (compatibilité des bases et des vidages écrits sans COLLATE sous la 10.x), non une limite.
Colonne CHARACTER SET latin1 (ou utf8mb3) : acceptée, rangée en utf8mb4 sous l'interclassement général (ou binaire pour latin1_bin), et affichée comme telle (CHARACTER SET utf8mb4 COLLATE utf8mb4_general_ci dans une table non générale ; la référence : CHARACTER SET latin1 COLLATE latin1_swedish_ci). Écart gardé : afficher latin1 ferait croire aux outils qui relisent SHOW CREATE TABLE que la colonne ne prend que des caractères latin1.
Numéro 255 (utf8mb4_0900_ai_ci) à la connexion : session en utf8mb4_general_ci (selon sa version, la référence en fait un alias d'un interclassement Unicode ; non relevé) ; une variable utilisateur passée à EXECUTE … USING y prend l'interclassement de la connexion, non le sien.
NEW.col d'une colonne générale et variables de routine générales : coercibles et non implicites (§ 13.3, « Variables, déclencheurs et routines »).
Littéraux des événements et des expressions de table : toujours en interclassement général (la référence garde, pour un événement, l'interclassement de connexion de sa création). Routines et déclencheurs écrits en langage PostgreSQL : rien n'est figé, interclassement général.
Écriture au travers d'une vue (UPDATE / DELETE / INSERT sur une vue modifiable, WITH CHECK OPTION) : les conditions de la vue, recopiées dans l'instruction réécrite, sont compilées sous l'interclassement de la session qui écrit, non sous celui figé avec la vue.
Défaut de base figé d'une routine ou d'un déclencheur : seul l'interclassement est gardé, non le jeu de caractères (toujours utf8mb4) ; la colonne character_set_client vaut toujours utf8mb4.
SHOW CREATE DATABASE d'une base à l'interclassement général garde la forme courte (CREATE DATABASE `nom`) ; la référence écrit toujours le commentaire /*!40100 … */.
CHARSET(), COLLATION() et COERCIBILITY() sont disponibles (chapitre 10, §10.9) : elles rendent le jeu, l'interclassement et la coercibilité (0 à 8) de l'expression telle que le moteur la résout, binary pour un nombre, une date ou NULL, latin1 / latin1_swedish_ci ou utf8mb3 pour CONVERT(… USING jeu).
Hors périmètre : interclassements NO PAD, sensibles à la casse ou aux accents autres que binaires (*_as_cs, *_ai_cs), linguistiques (german2, czech, turkish…), utf8mb4_0900_* : 1273.
Bases existantes : toute table créée avant les interclassements est lue en interclassement général, index et partitions inchangés ; seul un ALTER TABLE … COLLATE volontaire la change.