Tabla de contenidos
COLLATE
en sentencias SQLCOLLATE
BINARY
Este capítulo trata los siguientes temas:
Qué son los conjuntos de caracteres y colaciones.
El sistema por defecto de múltiples niveles
Sintaxis para especificar el conjunto de caracteres y colaciones.
Funciones y operaciones relacionadas.
Soporte Unicode
El significado de cada conjunto de caracteres individual y de cada colación
Los motores de almacenamiento MyISAM
,
MEMORY
, e InnoDB
soportan el
conjunto de caracteres.
Un conjunto de caracteres es un conjunto de símbolos y codificaciones. Una colación es un conjunto de reglas para comparar caracteres en un conjunto de caracteres. Vamos a dejar clara la distinción con un ejemplo de un conjunto de caracteres imaginario.
Supongamos que tenemos un alfabeto con cuatro letras:
'A
', 'B
',
'a
', 'b
'. Damos a cada letra
un número: 'A
' = 0, 'B
' =
1, 'a
' = 2, 'b
' = 3. La
letra 'A
' es un símbolo, el número 0 es la
codificación para
'A
', y la combinación de las cuatro letras y
sus codificaciones es un conjunto de
caracteres.
Suponga que queremos comparar dos cadenas de caracteres,
'A
' y 'B
'. La forma más
fácil de hacerlo es mirar las codificaciones: 0 para
'A
' y 1 para 'B
'. Ya que 0
es menor a 1, decimos que 'A
' es menor que
'B
'. Lo que acabamos de hacer es aplicar una
colación a un conjunto de caracteres. La colación es un conjunto
de reglas (sólo una en este caso): “compara las
codificaciones”. LLamamos a la más sencilla de todas las
colaciones una colación binaria.
Pero, ¿qué pasa si queremos decir que las letras en mayúsculas
y minúsculas son equivalentes? Entonces tendríamos como mínimo
dos reglas: (1) tratar las letras minúsuclas
'a
' y 'b
' como equivalentes
a 'A
' y 'B
'; (2) luego
comparar las codificaciones. Llamamos a esto una colación
no sensible a mayúsuculas y minúsculas
(case-insensitive). Es un poco más compleja que una
colación binaria.
En el mundo real, la mayoría de conjuntos de caracteres tienen
varios caracteres: no sólo 'A
' y
'B
' sino alfabetos completos, a veces varios
alfabetos o sistemas de escritura orientales con miles de
caracteres, junto con muchos símbolos especiales y signos de
puntuación. También en el mundo real, la mayoría de colaciones
tienen muchas reglas: no sólo distinción entre mayúsculas y
minúsculas, sino también sensibilidad a tildes (una
“tilde” es una marca añadida a un carácter como en
alemán 'Ö
') y mapeos de múltiples caracteres
(tales com la regla que 'Ö
' =
'OE
' en una de las dos colaciones alemanas).
MySQL 5.0 puede hacer lo siguiente:
Guardar cadenas de caracteres usando una variedad de conjuntos de caracteres
Comparar cadenas de caracteres usando una variedad de colaciones
Mezclar cadenas de caracteres con distintos conjuntos de caracteres o colaciones en el mismo servidor, la misma base de datos, o incluso la misma tabla
Permitir la especificación de un conjunto de caracteres y una colación en cualquier nivel
En este aspecto, no sólo MySQL 5.0 es mucho más flexible que versiones anteriores de MySQL, sino mejor que otros SGBDs. Sin embargo, para usar estas características de forma correcta, necesita saber qué conjuntos de caracteres y colaciones están disponibles, cómo cambiar los valores por defecto, y cómo afectan al comportamiento de operadores de cadenas de caracteres y funciones.
El servidor MySQL soporta varios conjuntos de caracteres. Para
listar los disponibles, use el comando SHOW CHARACTER
SET
:
mysql> SHOW CHARACTER SET; +----------+-----------------------------+---------------------+--------+ | Charset | Description | Default collation | Maxlen | +----------+-----------------------------+---------------------+--------+ | big5 | Big5 Traditional Chinese | big5_chinese_ci | 2 | | dec8 | DEC West European | dec8_swedish_ci | 1 | | cp850 | DOS West European | cp850_general_ci | 1 | | hp8 | HP West European | hp8_english_ci | 1 | | koi8r | KOI8-R Relcom Russian | koi8r_general_ci | 1 | | latin1 | ISO 8859-1 West European | latin1_swedish_ci | 1 | | latin2 | ISO 8859-2 Central European | latin2_general_ci | 1 | | swe7 | 7bit Swedish | swe7_swedish_ci | 1 | | ascii | US ASCII | ascii_general_ci | 1 | | ujis | EUC-JP Japanese | ujis_japanese_ci | 3 | | sjis | Shift-JIS Japanese | sjis_japanese_ci | 2 | | hebrew | ISO 8859-8 Hebrew | hebrew_general_ci | 1 | | tis620 | TIS620 Thai | tis620_thai_ci | 1 | | euckr | EUC-KR Korean | euckr_korean_ci | 2 | | koi8u | KOI8-U Ukrainian | koi8u_general_ci | 1 | | gb2312 | GB2312 Simplified Chinese | gb2312_chinese_ci | 2 | | greek | ISO 8859-7 Greek | greek_general_ci | 1 | | cp1250 | Windows Central European | cp1250_general_ci | 1 | | gbk | GBK Simplified Chinese | gbk_chinese_ci | 2 | | latin5 | ISO 8859-9 Turkish | latin5_turkish_ci | 1 | ...
(Para un listado completo, consulte Sección 10.10, “Conjuntos de caracteres y colaciones que soporta MySQL”.)
Cualquier conjunto de caracteres tiene siempre como mínimo una colación, aunque puede tener varias.
Para listar las colaciones para un conjunto de caracteres, use el
comando SHOW COLLATION
. Por ejemplo, para ver
las colaciones para el conjunto de caracteres
latin1
(“ISO-8859-1 Europa
Occidental”), use el siguiente comando, que muestra el
nombre de las colaciones que empiezan con
latin1
:
mysql> SHOW COLLATION LIKE 'latin1%'; +---------------------+---------+----+---------+----------+---------+ | Collation | Charset | Id | Default | Compiled | Sortlen | +---------------------+---------+----+---------+----------+---------+ | latin1_german1_ci | latin1 | 5 | | | 0 | | latin1_swedish_ci | latin1 | 8 | Yes | Yes | 1 | | latin1_danish_ci | latin1 | 15 | | | 0 | | latin1_german2_ci | latin1 | 31 | | Yes | 2 | | latin1_bin | latin1 | 47 | | Yes | 1 | | latin1_general_ci | latin1 | 48 | | | 0 | | latin1_general_cs | latin1 | 49 | | | 0 | | latin1_spanish_ci | latin1 | 94 | | | 0 | +---------------------+---------+----+---------+----------+---------+
Las colaciones para latin1
tienen los
siguientes significados:
Colación | Significado |
latin1_german1_ci | Alemán DIN-1 |
latin1_swedish_ci | Sueco/Finlandés |
latin1_danish_ci | Danés/Noruego |
latin1_german2_ci | Alemán DIN-2 |
latin1_bin | Binario según codificación latin1 |
latin1_general_ci | Multilingüe (Europa Occidental) |
latin1_general_cs | Multilingüe (ISO Europa Occidental), sensible a mayúsculas |
latin1_spanish_ci | Español moderno |
Las colaciones tienen las siguientes características generales:
Dos conjuntos de caracteres distintos no pueden tener la misma colación.
Cada conjunto de caracteres tiene una colación que es la
colación por defecto. Por ejemplo, la
colación por defecto para latin1
es
latin1_swedish_ci
.
Hay una convención para nombres de colaciones: empiezan con
el nombre del conjunto de caracteres al que están asociados,
normalmente incluyen el nombre del idioma, y acaban con
_ci
(no distingue entre mayúsculas y
minúsculas), _cs
(distingue entre
mayúsculas y minúsculas), o _bin
(binario).
COLLATE
en sentencias SQLCOLLATE
BINARY
Hay configuraciones por defecto para conjuntos de caracteres y colaciones en cuatro niveles: servidor, base de datos, tabla, y conexión. La siguiente descripción puede parecer compleja, pero en la práctica este funcionamiento de varios niveles conduce a resultados naturales y obvios.
El servidor MySQL tiene un conjunto de caracteres para el servidor y una colación, y ambos deben ser distintos al valor nulo.
MySQL determina el conjunto de caracteres y la colación del servidor con el siguiente procedimiento:
Según las opciones en efecto cuando arranca el servidor
Según los valores cambiados en tiempo de ejecución
A nivel de servidor, la decisión es simple. El conjunto de
caracteres y la colación del servidor dependen inicialmente de
la opción usada al arrancar mysqld. Se puede
usar --default-character-set
para el conjunto
de caracteres y a éste se puede añadir
--default-collation
para la colación. No
especificar un conjunto de caracteres, es como especificar
--default-character-set=latin1
. Especificar
sólo un conjunto de caracteres (por ejemplo,
latin1
) pero no una colación, es como
especificar --default-charset=latin1
--default-collation=latin1_swedish_ci
, ya que
latin1_swedish_ci
es la colación por defecto
para latin1
. Por lo tanto, los siguientes
tres comandos tienen el mismo efecto:
shell> mysqld shell> mysqld --default-character-set=latin1 shell> mysqld --default-character-set=latin1 \ --default-collation=latin1_swedish_ci
Una forma de cambiar la especificación es recompilando. Para
cambiar el conjunto de caracteres por defecto y la colación al
compilar las fuentes, debe utilizarse:
--with-charset
y
--with-collation
como argumentos para
configure. Por ejemplo:
shell> ./configure --with-charset=latin1
O:
shell> ./configure --with-charset=latin1 \ --with-collation=latin1_german1_ci
Tanto mysqld como configure verifican que la combinación del conjunto de caracteres y la colación es válida. Si no lo es, cada programa muestra un mensaje de error y acaba.
El conjunto de caracteres y la colación actuales están
disponibles como los valores de las variables
character_set_server
y
collation_server
. Estas variables pueden
cambiarse en tiempo de ejecución.
Cada base de datos tiene un conjunto de caracteres y una
colación que no pueden ser nulos. Los comandos CREATE
DATABASE
y ALTER DATABASE
tienen
cláusulas opcionales para especificar el conjunto de caracteres
y colación de la base de datos:
CREATE DATABASEnombre_de_base_de_datos
[[DEFAULT] CHARACTER SETnombre_de_conjunto_de_caracteres
] [[DEFAULT] COLLATEnombre_de_colación
] ALTER DATABASEnombre_de_base_de_datos
[[DEFAULT] CHARACTER SETnombre_de_conjunto_de_caracteres
] [[DEFAULT] COLLATEnombre_de_colación
]
Ejemplo:
CREATE DATABASE nombre_de_base_de_datos
DEFAULT CHARACTER SET latin1 COLLATE latin1_swedish_ci;
MySQL elige el conjunto de caracteres y colación de la base de datos así:
Si tanto CHARACTER SET
como X
COLLATE
se especifican,
entonces el conjunto de caracteres es
Y
X
y la colación
Y
.
Si CHARACTER SET
se especifica sin
X
COLLATE
, entonces el conjunto de
caracteres es X
y la colación es
la de defecto.
En el resto de casos, es el conjunto de caracteres y la colación del servidor.
La sintaxis de MySQL CREATE DATABASE ... DEFAULT
CHARACTER SET ...
es análoga a la sintaxis estándar
SQL CREATE SCHEMA ... CHARACTER SET ...
. Por
ello, es posible crear bases de datos con distintos conjuntos de
caracteres y colaciones en el mismo servidor MySQL.
El conjunto de caracteres de la base de datos y la colación se
usan como valores por defecto para una tabla si no se especifica
el conjunto de caracteres y colación en el comando
CREATE TABLE
. No tienen otro propósito.
El conjunto de caracteres y colación para la base de datos por
defecto están disponibles como los valores de las variables
character_set_database
y
collation_database
. El servidor obtiene
estas variables siempre que la base de datos por defecto cambia.
Si no hay base de datos por defecto, las variables tienen el
mismo valor que las variables correspondiente del lado del
servidor, character_set_server
y
collation_server
.
Cada tabla tiene un conjunto de caracteres y colación que no
pueden ser nulas. Los comandos CREATE TABLE
y
ALTER TABLE
tienen cláusulas opcionales para
especificar el conjunto de caracteres y la colación:
CREATE TABLEnombre_de_tabla
(lista_de_columnas
) [DEFAULT CHARACTER SETnombre_de_conjunto_de_caracteres
[COLLATEnombre_de_colación
]] ALTER TABLEnombre_de_tabla
[DEFAULT CHARACTER SETnombre_de_conjunto_de_caracteres
] [COLLATEnombre_de_colación
]
Ejemplo:
CREATE TABLE t1 ( ... ) DEFAULT CHARACTER SET latin1 COLLATE latin1_danish_ci;
MySQL elije el conjunto de caracteres y colación de la siguiente forma:
Si se especifican CHARACTER SET
y X
COLLATE
, entonces el
conjunto de caracteres es Y
X
y la
colación Y
.
Si se especifica CHARACTER SET
sin
X
COLLATE
, el conjunto de caracteres es
X
y la colación es la de
defecto.
En cualquier otro caso, el conjunto de caracteres y colación son las del servidor.
El conjunto de caracteres y colación de la tabla se usan como valores por defecto si el conjunto de caracteres y la colación no se especifican en la definición de las columnas. El conjunto de caracteres de la tabla y la colación son extensiones MySQL; no hay mucho al respecto en el estándar SQL.
Cada columna “carácter” (esto es, una columna de
tipo CHAR
, VARCHAR
, o
TEXT
) tiene un conjunto de caracteres y
colación de columna, que no pueden ser nulos. La sintaxis de
definición de columnas tiene cláusulas opcionales para
especificar el conjunto de caracteres y la colación:
nombre_de_columna
{CHAR | VARCHAR | TEXT} (ancho_de_columna
) [CHARACTER SETnombre_de_conjunto_de_caracteres
[COLLATEnombre_de_colación
]]
Ejemplo:
CREATE TABLE Table1 ( column1 VARCHAR(5) CHARACTER SET latin1 COLLATE latin1_german1_ci );
MySQL elige el conjunto de caracteres y la colación de la columna de la siguiente forma:
Si se especifican CHARACTER SET
y X
COLLATE
, entonces el
conjunto de caracteres es Y
X
y la
colación Y
.
Si se especifica CHARACTER SET
sin
X
COLLATE
, el conjunto de caracteres es
X
y la colación es la de
defecto.
En cualquier otro caso, se usan el conjunto de caracteres y la colación de la tabla.
Las cláusulas CHARACTER SET
y
COLLATE
son de SQL estándar.
Los siguientes ejemplos muestran cómo MySQL determina los valores del conjunto de caracteres y colación por defecto.
Ejemplo 1: Definición de tabla y columna
CREATE TABLE t1 ( c1 CHAR(10) CHARACTER SET latin1 COLLATE latin1_german1_ci ) DEFAULT CHARACTER SET latin2 COLLATE latin2_bin;
Aquí tenemos una columna con un conjunto de caracteres
latin1
y una colación
latin1_german1_ci
. La definición es
explícita, así que es sencillo. Debe tenerse en cuenta que no
hay problema al almacenar una columna latin1
en una tabla latin2
.
Ejemplo 2: Definición de tabla y columna
CREATE TABLE t1 ( c1 CHAR(10) CHARACTER SET latin1 ) DEFAULT CHARACTER SET latin1 COLLATE latin1_danish_ci;
Ahora tenemos una columna con un conjunto de caracteres
latin1
y la colación por defecto. Aunque
puede parecer normal, la colación por defecto no es la del
nivel de tabla. En lugar de ello, ya que la colación para
latin1
siempre es
latin1_swedish_ci
, la columna
c1
tiene una colación de
latin1_swedish_ci
(no
latin1_danish_ci
).
Ejemplo 3: Definición de tabla y columna
CREATE TABLE t1 ( c1 CHAR(10) ) DEFAULT CHARACTER SET latin1 COLLATE latin1_danish_ci;
Tenemos una columna con un conjunto de caracteres y colación
por defecto. Bajo esta circunstancia, MySQL busca a nivel de
tabla para determinar el conjunto de caracteres y colación para
la columna. Así, el conjunto de caracteres para la columna
c1
es latin1
y su
colación es latin1_danish_ci
.
Ejemplo 4: Definición de base de datos, tabla y columna
CREATE DATABASE d1 DEFAULT CHARACTER SET latin2 COLLATE latin2_czech_ci; USE d1; CREATE TABLE t1 ( c1 CHAR(10) );
Creamos una columna sin especificar su conjunto de caracteres y
colación. Tampoco especificamos un conjunto de caracteres y
colación a nivel de tabla. En este caso, MySQL busca a nivel de
base de datos para inspirarse. (La configuración de la base de
datos pasa a ser la configuración de la tabla, y posteriormente
la configuración de columna). Así, el conjunto de caracteres
para la columna c1
es
latin2
y su colación es
latin2_czech_ci
.
Varias variables de sistema de conjunto de caracteres y colaciones están relacionadas con la interacción cliente-servidor. Algunas de ellas se han mencionado en secciones anteriores:
El conjunto de caracteres y la colación del servidor están
disponibles como los valores de las variables
character_set_server
y
collation_server
.
El conjunto de caracteres y la colación de la base de datos
por defecto están disponibles como valores de las variables
character_set_database
y
collation_database
.
Variables de conjuntos de caracteres y colaciones adicionales están involucradas en tratar el tráfico para la conexión entre un cliente y el servidor. Cada cliente tiene variables para el conjunto de caracteres y colación relacionados con la conexión.
Una “conexión” es lo que se hace al conectarse con el servidor. El cliente envía comandos SQL, tales como consultas, mediante la conexión al servidor. El servidor envía respuestas, tales como resultados, mediante la conexión de vuelta al cliente. Esto genera preguntas sobre tratamiento de conjuntos de caracteres y colaciones para conexiones de cliente, cada una de ellas puede responderse mediante variables de sistema:
¿ Qué conjunto de caracteres usa una consulta al salir del cliente?
El servidor toma la variable
character_set_client
para usarla en las
consultas enviadas por el cliente.
¿ Qué conjunto de caracteres debería usar el servidor para traducir una consulta tras recibirla?
Para esto, el servidor usa
character_set_connection
y
collation_connection
. Esto convierte las
consultas enviadas por el cliente de
character_set_client
a
character_set_connection
(excepto para
cadenas de caracteres literales que tienen un introductor
como _latin1
o _utf8
).
collation_connection
es importante para
comparaciones de cadenas de caracteres literales. Para
comparaciones de cadenas de caracteres con valores de
columnas no importa, ya que las columnas tienen una
precedencia mayor en las colaciones.
¿ Qué conjunto de caracteres debería usar el servidor para traducir los resultados o errores antes de enviar el mensaje de vuelta al cliente?
La variable character_set_results
indica
el conjunto de caracteres usado por el servidor para
devolver los resultados de las consultas al cliente. Esto
incluye datos resultantes como los valores de las columnas,
y metadatos resultantes como nombres de columnas.
Puede ajustar estas variables, o puede depender de los valores por defecto (en tal caso, puede obviar esta sección).
Hay dos comandos que afectan al conjunto de caracteres de conexión:
SET NAMES 'nombre_de_conjunto_de_caracteres
' SET CHARACTER SETnombre_de_conjunto_de_caracteres
SET NAMES
indica qué hay en el comando SQL
que envía el cliente. Por lo tanto, SET NAMES
'cp1251'
le dice al servidor “los próximos
mensajes entrantes de este cliente están en el conjunto de
caracteres cp1251
.” También
especifica el conjunto de caracteres para los resultados que el
servidor devuelve al cliente. (Por ejemplo, indica los conjuntos
de caracteres de la columna si usa el comando
SELECT
.)
Un comando SET NAMES
'
es equivalente a estos
tres comandos:
x
'
mysql> SET character_set_client =x
; mysql> SET character_set_results =x
; mysql> SET character_set_connection =x
;
Cambiar character_set_connection
a
x
también cambia
collation_connection
de la colación por
defecto a x
.
SET CHARACTER SET
es similar pero cambia el
conjunto de caracteres y la colación para la conexión para ser
las de la base de datos por defecto. Un comando SET
CHARACTER SET x
es equivalente a estos tres comandos:
mysql> SET character_set_client =x
; mysql> SET character_set_results =x
; mysql> SET collation_connection = @@collation_database;
Cuando un cliente se conecta, envía al servidor el nombre del
conjunto de caracteres que quiere usar. El servidor cambia las
variables character_set_client
,
character_set_results
, y
character_set_connection
para ese conjunto de
caracteres. (De hecho, el servidor efectúa una operación
SET NAMES
usando el conjunto de caracteres).
No es necesario ejecutar SET NAMES
cada vez
que se arranca el cliente mysql, aunque se
quiera utilizar un conjunto de caracteres diferente del que hay
por defecto. Puede añadirse la opción
--default-character-set
en la línea de
comandos de mysql, o en el fichero de
opciones. Por ejemplo, el siguiente fichero de opciones cambia
las variables del conjunto de caracteres a
koi8r
cada vez que se ejecuta
mysql:
[mysql] default-character-set=koi8r
Ejemplo: Supongamos que column1
se define
como CHAR(5) CHARACTER SET latin2
. Si no se
especifica SET NAMES
o SET CHARACTER
SET
, entonces para SELECT column1 FROM
t
, el servidor devuelve todos los valores para
column1
usando el conjunto de caracteres que
el cliente especificó al conectar. Por otro lado, si se
especifica SET NAMES 'latin1'
o SET
CHARACTER SET latin1
, entonces justo antes de devolver
los resultados, el servidor convierte el valor
latin2
a latin1
. La
conversión puede perder información si hay caracteres que no
están en ambos conjuntos de caracteres.
Si no se quiere que el servidor haga ninguna conversión, debe
cambiarse character_set_results
a
NULL
:
mysql> SET character_set_results = NULL;
Cada literal de cadenas de caracteres tiene un conjunto de caracteres y una colación, que no pueden ser nulos.
Un literal de cadena de caracteres puede tener un introductor de
conjunto de caracteres opcional y una cláusula
COLLATE
:
[_nombre_de_conjunto_de_caracteres
]'cadena_de_texto
' [COLLATEnombre_de_colación
]
Ejemplos:
SELECT 'cadena_de_texto
'; SELECT _latin1'cadena_de_texto
'; SELECT _latin1'cadena_de_texto
' COLLATE latin1_danish_ci;
Para el comando simple SELECT
'
, la
cadena de caracteres tiene el conjunto de caracteres y colación
definida por las variables de sistema
cadena_de_texto
'character_set_connection
y
collation_connection
.
La expresión
_
se llama formalmente introductor. Le dice
al parser: “la siguiente cadena de caracteres utiliza el
conjunto de caracteres nombre_de_conjunto_de_caracteres
X
”.
Esto ha sido fuente de confusión en el pasado. Enfaticemos pues
que un introductor no causa ninguna conversión, sino que es
estrictamente una señal que no cambia el valor de la cadena de
caracteres. Un introductor también es legal antes de la
notación para literales hexadecimales y literales numéricos
hexadecimales
(x'
y
literal
'0x
), y antes
de nnnn
?
(parámetros de sustitución al usar
comandos preparados dentro de la interfície de un lenguaje de
programación).
Ejemplos:
SELECT _latin1 x'AABBCC'; SELECT _latin1 0xAABBCC; SELECT _latin1 ?;
MySQL determina el conjunto de caracteres y colación para un literal así:
Si se especifican _X
y
COLLATE
,
entonces el conjunto de caracteres es
Y
X
y se usa la colación
Y
.
Si se especifica _X
pero no se
especifica COLLATE
, entonces el conjunto
de caracteres es X
y el conjunto
de caracteres es el de defecto.
En cualquier otro caso, se utilizan el conjunto de
caracteres y la colación que hay en las variables de
sistema character_set_connection
y
collation_connection
.
Ejemplos:
Una cadena de caracteres con conjunto de caracteres
latin1
y colación
latin1_german1_ci
:
SELECT _latin1'Müller' COLLATE latin1_german1_ci;
Una cadena de caracteres con conjunto de caracteres
latin1
y su colación por defecto (esto
es, latin1_swedish_ci
):
SELECT _latin1'Müller';
Una cadena de caracteres con conjunto de caracteres y colación por defecto de la conexión:
SELECT 'Müller';
Los introductores de conjunto de caracteres y la cláusula
COLLATE
se implementan según las
especificaciones del estándar SQL.
Con la cláusula COLLATE
, puede obviarse la
colación por defecto para comparación.
COLLATE
puede usarse en varias partes de los
comandos SQL. Aquí se muestran algunos ejemplos:
Con ORDER BY
:
SELECT k FROM t1 ORDER BY k COLLATE latin1_german2_ci;
Con AS
:
SELECT k COLLATE latin1_german2_ci AS k1 FROM t1 ORDER BY k1;
Con GROUP BY
:
SELECT k FROM t1 GROUP BY k COLLATE latin1_german2_ci;
Con funciones agregadas:
SELECT MAX(k COLLATE latin1_german2_ci) FROM t1;
Con DISTINCT
:
SELECT DISTINCT k COLLATE latin1_german2_ci FROM t1;
Con WHERE
:
SELECT * FROM t1 WHERE _latin1 'Müller' COLLATE latin1_german2_ci = k;
SELECT * FROM t1 WHERE k LIKE _latin1 'Müller' COLLATE latin1_german2_ci;
Con HAVING
:
SELECT k FROM t1 GROUP BY k HAVING k = _latin1 'Müller' COLLATE latin1_german2_ci;
La cláusula COLLATE
tiene alta precedencia
(mayor que ||
), así que las siguientes dos
expresiones son equivalentes:
x || y COLLATE z x || (y COLLATE z)
El operador BINARY
es una abreviación de la
cláusula COLLATE
. BINARY
'
es equivalente a
x
''
, donde
x
' COLLATE
y
y
es el nombre de la colación
binaria para el conjunto de caracteres de
'x
'. Cada conjunto de caracteres
tiene una colación binaria. Por ejemplo, la colación binaria
para el conjunto de caracteres latin1
es
latin1_bin
, así si la columna
a
es del conjunto de caracteres
latin1
, los siguientes dos comandos tienen el
mismo efecto:
SELECT * FROM t1 ORDER BY BINARY a; SELECT * FROM t1 ORDER BY a COLLATE latin1_bin;
En la gran mayoría de consultas, resulta obvio qué colación
usa MySQL para resolver una operación de comparación. Por
ejemplo, en los siguientes casos, debe quedar claro que la
colación es “la colación de la columna
x
”:
SELECT x FROM T ORDER BY x; SELECT x FROM T WHERE x = x; SELECT DISTINCT x FROM T;
Sin embargo, cuando están implicados varios operandos, puede haber ambigüedad. Por ejemplo:
SELECT x FROM T WHERE x = 'Y';
¿Esta consulta debe usar la colación de la columna
x
, o de la columna de caracteres literal
'Y'
?
SQL estándar resuelve tales cuestiones usando lo que se solía
llamar reglas “coercitivas”. Es decir: Como
x
e 'Y'
tienen colaciones,
¿cuál tiene precedencia? Puede ser difícil de resolver, pero
las siguientes reglas resuelven la mayoría de situaciones:
Una cláusula COLLATE
explícita tiene
una coercibilidad de 0. (No es coercible en absoluto.)
La concatenación de dos cadenas de caracteres con diferentes colaciones tiene una coercibilidad de 1.
La colación de una columna tiene una coercibilidad de 2.
Una “constante de sistema” (la cadena de
caracteres retornada por funciones como
USER()
o VERSION()
)
tiene una coercibilidad de 3.
Una colación de un literal tiene una coercibilidad de 4.
NULL
o una expresión derivada de
NULL
tiene una coercibilidad de 5.
Los valores de coercibilidad precedentes son los de MySQL 5.0.3. Consúltese la nota posterior en esta sección para más información relacionada con versiones.
Estas reglas resuelven ambigüedades como:
Uso de la colación con el valor más bajo de coercibilidad.
Si ambos operadodres tienen la misma coercibilidad, entonces hay un error si las colaciones son distintas.
Ejemplos:
columna1 = 'A' | Usa colación de columna1 |
columna1 = 'A' COLLATE x | Usa colación de 'A' |
columna1 COLLATE x = 'A' COLLATE y | Error |
La función COERCIBILITY()
puede usarse para
determinar la coercibilidad de una expresión de cadena de
caracteres:
mysql> SELECT COERCIBILITY('A' COLLATE latin1_swedish_ci); -> 0 mysql> SELECT COERCIBILITY(VERSION()); -> 3 mysql> SELECT COERCIBILITY('A'); -> 4
Consulte Sección 12.9.3, “Funciones de información”.
En MySQL 5.0 antes de la versión 5.0.3, no hay constantes de
sistema o coercibilidad ignorables. Funciones como
USER()
tienen una coercibilidad de 2 en lugar
de 3, y los literales tienen una coercibilidad de 3 en lugar de
4.
Recuerde que cada conjunto de caracteres tiene una o más
colaciones, y cada colación está asociadad con uno y sólo un
conjunto de caracteres. Por lo tanto, los siguientes comandos
causan un mensaje de error ya que la colación
latin2_bin
no es legal con el conjunto de
caracteres latin1
:
mysql> SELECT _latin1 'x' COLLATE latin2_bin; ERROR 1251: COLLATION 'latin2_bin' is not valid for CHARACTER SET 'latin1'
Supongamos que la columna X
en la tabla
T
tiene estos valores de columna
latin1
:
Muffler Müller MX Systems MySQL
Y supongamos que los valores de la columna se retornan usando los siguientes comandos:
SELECT X FROM T ORDER BY X COLLATE nombre_de_colación
;
El orden resultante de los valores para diferentes colaciones se muestra en esta tabla:
latin1_swedish_ci | latin1_german1_ci | latin1_german2_ci |
Muffler | Muffler | Müller |
MX Systems | Müller | Muffler |
Müller | MX Systems | MX Systems |
MySQL | MySQL | MySQL |
La tabla es un ejemplo que muestra el efecto de la utilización
de diferentes colaciones en una cláusula ORDER
BY
. El carácter que causa el orden de ordenación
diferente en este ejemplo es la U con dos puntos encima
(ü
), que los alemanes llaman
"U-umlaut".
La primera columna muestra el resultado de
SELECT
usando la regla de colación
Sueca/Finlandesa, que dice que U-umlaut se ordena con Y.
La segunda columna muestra el resultado de
SELECT
usando la regla alemana DIN-1, que
dice que U-umlaut se ordena con U.
La tercera columna muestra el resultado de
SELECT
usando la regla alemana DIN-2, que
dice que U-umlaut se ordena con UE.
Esta sección describe operaciones que tienen en cuenta información sobre el conjunto de caracteres en MySQL 5.0.
MySQL tiene varios operadores y funciones que retornan una cadena de caracteres. Esta sección responde a la pregunta: ¿Cuál es el conjunto de caracteres y colación de esta cadena de caracteres?
Para funciones simples que toman una entrada de cadenas de
caracteres y devuelven una cadena de caracteres como salida, el
conjunto de caracteres y colación de la salida son las mismas
que las de la entrada. Por ejemplo
UPPER(
devuelve
una cadena de caracteres con un conjunto de caracteres y
colación iguales a las de X
)X
. Lo
mismo se aplica para INSTR()
,
LCASE()
, LOWER()
,
LTRIM()
, MID()
,
REPEAT()
, REPLACE()
,
REVERSE()
, RIGHT()
,
RPAD()
, RTRIM()
,
SOUNDEX()
, SUBSTRING()
,
TRIM()
, UCASE()
, y
UPPER()
. (Debe tenerse en cuenta que la
función REPLACE()
, a diferencia del resto de
funciones, ignora siempre la colación de la cadena de
caracteres de entrada y realiza una comparación que no
distingue entre mayúsculas y minúsculas).
Para operaciones que combinan varias cadenas de caracteres de entrada y devuelven una única cadena de salida, se aplica la “regla de agregación”estándar de SQL:
Si hay un COLLATE
explícito, usa
X
X
.
Si hay un COLLATE
y X
COLLATE
explícitos, muestra
un error.
Y
De lo contrario, si todas las colaciones son
X
, usa
X
.
En cualquier otro caso, el resultado no tiene colación.
Por ejemplo, con CASE ... WHEN a THEN b WHEN b THEN c
COLLATE
, la colación
resultante es X
ENDX
. Lo mismo se aplica
para CASE
, UNION
,
||
, CONCAT()
,
ELT()
, GREATEST()
,
IF()
, y LEAST()
.
Para operaciones que conviertan datos de tipo carácter, el
conjunto de caracteres y colación de las cadenas de caracteres
resultantes de las operaciones se definen por las variables de
sistema character_set_connection
y
collation_connection
. Esto se aplica en
CAST()
, CHAR()
,
CONV()
, FORMAT()
,
HEX()
, y SPACE()
.
CONVERT()
proporciona un modo de convertir
datos entre distintos conjuntos de caracteres. La sintaxis es:
CONVERT(expr
USINGtranscoding_name
)
En MySQL, "transcoding names" es lo mismo que los conjuntos de caracteres correspondientes.
Ejemplos:
SELECT CONVERT(_latin1'Müller' USING utf8); INSERT INTO utf8table (utf8column) SELECT CONVERT(latin1field USING utf8) FROM latin1table;
CONVERT(... USING ...)
se implementa según
la especificación de SQL estándar.
En modo SQL TRADITIONAL
, si convierte una
cadena de caracteres de fecha “zero” en una fecha,
CONVERT()
retorna NULL
.
MySQL 5.0.4 y versiones posteriores también muestran un mensaje
de advertencia.
Puede usar CAST()
para convertir una cadena
de caracteres a un conjunto de caracteres distinto. La sintaxis
es:
CAST(cadena_de_caracteres
AStipo_de_datos
CHARACTER SETnombre_de_conjunto_de_caracteres
)
Ejemplo:
SELECT CAST(_latin1'test' AS CHAR CHARACTER SET utf8);
Si usa CAST()
sin especificar
CHARACTER SET
, el conjunto de caracteres y
colación resultantes se definen por las variables de sistema
character_set_connection
y
collation_connection
. Si usa
CAST()
con CHARACTER SET
X
, el conjunto de caracteres y colación resultantes
son X
y la colación por defecto de
X
.
Puede no usar una cláusula COLLATE
dentro de
CAST()
, pero puede hacerlo fuera. Esto es,
CAST(... COLLATE ...)
es ilegal, pero
CAST(...) COLLATE ...
es legal.
Ejemplo:
SELECT CAST(_latin1'test' AS CHAR CHARACTER SET utf8) COLLATE utf8_bin;
En modo SQL TRADITIONAL
, si convierte una
cadena de caracteres de fecha “zero” a una fecha,
CAST()
retorna NULL
. MySQL
5.0.4 y versiones posteriores muestran un mensaje de
advertencia.
Varios comandos SHOW
proporcionan
información adicional de conjuntos de caracteres. Esto incluye
SHOW CHARACTER SET
, SHOW
COLLATION
, SHOW CREATE DATABASE
,
SHOW CREATE TABLE
and SHOW
COLUMNS
.
El comando SHOW CHARACTER SET
muestra todos
los conjuntos de caracteres disponibles. Tiene una cláusula
opcional LIKE
que indica con qué nombres de
conjunto de caracteres comparar. Por ejemplo:
mysql> SHOW CHARACTER SET LIKE 'latin%'; +---------+-----------------------------+-------------------+--------+ | Charset | Description | Default collation | Maxlen | +---------+-----------------------------+-------------------+--------+ | latin1 | ISO 8859-1 West European | latin1_swedish_ci | 1 | | latin2 | ISO 8859-2 Central European | latin2_general_ci | 1 | | latin5 | ISO 8859-9 Turkish | latin5_turkish_ci | 1 | | latin7 | ISO 8859-13 Baltic | latin7_general_ci | 1 | +---------+-----------------------------+-------------------+--------+
Consulte Sección 13.5.4.1, “Sintaxis de SHOW CHARACTER SET
”.
La salida de SHOW COLLATION
incluye todos los
conjuntos de caracteres. Tiene una cláusula opcional
LIKE
que indica con qué nombres de conjunto
de caracteres comparar. Por ejemplo:
mysql> SHOW COLLATION LIKE 'latin1%'; +-------------------+---------+----+---------+----------+---------+ | Collation | Charset | Id | Default | Compiled | Sortlen | +-------------------+---------+----+---------+----------+---------+ | latin1_german1_ci | latin1 | 5 | | | 0 | | latin1_swedish_ci | latin1 | 8 | Yes | Yes | 0 | | latin1_danish_ci | latin1 | 15 | | | 0 | | latin1_german2_ci | latin1 | 31 | | Yes | 2 | | latin1_bin | latin1 | 47 | | Yes | 0 | | latin1_general_ci | latin1 | 48 | | | 0 | | latin1_general_cs | latin1 | 49 | | | 0 | | latin1_spanish_ci | latin1 | 94 | | | 0 | +-------------------+---------+----+---------+----------+---------+
Consulte Sección 13.5.4.2, “Sintaxis de SHOW COLLATION
”.
SHOW CREATE DATABASE
muestra el comando
CREATE DATABASE
que crea una base de datos
dada. El resultado incluye todas las opciones de la base de
datos DEFAULT CHARACTER SET
y
COLLATE
están soportadas. Todas las opciones
de las bases de datos se guardan en un fichero de datos llamado
db.opt
que se encuentra en el directorio de
la base de datos.
mysql> SHOW CREATE DATABASE test; +----------+-----------------------------------------------------------------+ | Database | Create Database | +----------+-----------------------------------------------------------------+ | test | CREATE DATABASE `test` /*!40100 DEFAULT CHARACTER SET latin1 */ | +----------+-----------------------------------------------------------------+
Consulte Sección 13.5.4.4, “Sintaxis de SHOW CREATE DATABASE
”.
SHOW CREATE TABLE
es similar, pero muestra el
comando CREATE TABLE
para crear una tabla
dada. Las definiciones de columnas indican cualquier
especificación del conjunto de caracteres, y las opciones de
tabla incluyen información del conjunto de caracteres.
Consulte Sección 13.5.4.5, “Sintaxis de SHOW CREATE TABLE
”.
El comando SHOW COLUMNS
muestra la colación
de las columnas de una tabla cuando se invoca como SHOW
FULL COLUMNS
. Columnas con tipos de datos
CHAR
, VARCHAR
, o
TEXT
tienen colaciones
no-NULL
. Tipos numéricos y otros tipos
no-carácter tiene colaciones NULL
. Por
ejemplo:
mysql> SHOW FULL COLUMNS FROM person\G *************************** 1. row *************************** Field: id Type: smallint(5) unsigned Collation: NULL Null: NO Key: PRI Default: NULL Extra: auto_increment Privileges: select,insert,update,references Comment: *************************** 2. row *************************** Field: name Type: char(60) Collation: latin1_swedish_ci Null: NO Key: Default: Extra: Privileges: select,insert,update,references Comment:
El conjunto de caracteres no es parte de lo que se muestra. (El nombre del conjunto de caracteres está implícito en el nombre de la colación.)
En MySQL 5.0, hay dos conjuntos de caracteres para guardar datos Unicode:
ucs2
, el conjunto de caracteres UCS-2
Unicode.
utf8
, la codificación UTF8 del conjunto de
caracteres Unicode.
En UCS-2 (representación binaria de Unicode), cada carácter se representa con un código de dos bytes Unicode con el byte más significativo primero. Por ejemplo: "LETRA LATINA MAYÚSCULA A" tiene código 0x0041 y se almacena como una secuencia de dos bytes: 0x00 0x41. "LETRA MINÚSCULA CIRÍLICA YERU" (Unicode 0x044B) se almacenca como la secuencia de dos bytes: 0x04 0x4B. Para caracteres Unicode y sus códigos, consulte Unicode Home Page.
Actualmente, UCS-2 no puede usarse como un conjunto de caracteres
cliente, lo que significa que SET NAMES 'ucs2'
no funciona.
El conjunto de caracteres UTF8 (transformación de la representación Unicode) es una forma alternativa de guardar los datos Unicode. Está implementado según el RFC 3629. La idea del conjunto de caracteres UTF8 es que varios caracteres Unicode se codifican usando secuencias de bytes de longitudes diferentes:
Letras básicas latinas, dígitos y signos de puntuación usan un byte.
La mayoría de letras europeas y del Medio Oriente se guardan en una secuencia de dos bytes: letras latinas extendidas (con tilde, diéresis, etc), cirílico, griego, armenio, hebreo, arábigo, sirio, y otros.
Ideogramas koreanos, chinos, y japoneses usan secuencias de tres bytes.
RFC 3629 describe secuencias de codificación que usan de uno a cuatro bytes. Actualmente, el soporte MySQL UTF8 no incluye secuencias de cuatro bytes. (Un estándar antiguo de codificación UTF8 se da en RFC 2279, que describe secuencias UTF8 que usan de uno a seis bytes. RFC 3629 sustituye al obsoleto RFC 2279; por esta razón, las secuencias con cinco y seis bytes ya no se usan).
Consejo: para ahorrar espacio con UTF8, use
VARCHAR
en lugar de CHAR
. De
otro modo, MySQL tiene que reservar 30 bytes para una columna
CHAR(10) CHARACTER SET utf8
, ya que es la
longitud máxima posible.
Los metadatos son los datos acerca de los datos. Cualquier cosa
que describa la base de datos, opuestamente a los contenidos de la
misma, son metadatos. Así, los nombres de columna, nombres de
base de datos, nombres de usuario, nombres de versión y la
mayoría de resultados de SHOW
son metadatos.
La representación de los metadatos debe satisfacer estos requerimientos:
Todos los metadatos deben ser del mismo conjunto de
caracteres. De otro modo SHOW
no
funcionaría correctamente ya que distintos registros en la
misma columna tendrían distintos conjuntos de caracteres.
Los metadatos deben incluir todos los caracteres en todos los idiomas. De otro modo, los usuarios no serían capaces de nombrar tablas y columnas en su propio idioma.
Para satisfacer ambos requerimientos, MySQL guarda los metadatos en un conjunto de caracteres Unicode, llamado UTF8. Esto no causa ningún problema si no se utilizan nunca caracteres acentuados o no-latinos. Si se utilizan, debe tenerse en cuenta que los metadatos están en UTF8.
Esto significa que las funciones USER()
,
CURRENT_USER()
, DATABASE()
,
y VERSION()
tienen el conjunto de caracteres
UTF8 por defecto, al igual que sinónimos como
SESSION_USER()
y
SYSTEM_USER()
.
El servidor activa la variable de sistema
character_set_system
con el nombre del conjunto
de caracteres de los metadatos:
mysql> SHOW VARIABLES LIKE 'character_set_system'; +----------------------+-------+ | Variable_name | Value | +----------------------+-------+ | character_set_system | utf8 | +----------------------+-------+
El almacenamiento de metadatos usando Unicode
no significa que las cabeceras de columnas y
los resultados de la función DESCRIBE
estén
en el conjunto de caracteres
character_set_system
por defecto. Cuando
introduce SELECT column1 FROM t
, el nombre
column1
mismo vuelve del servidor al cliente
con el conjunto de caracteres determinado por el comando
SET NAMES
. Más específicamente, el conjunto
de caracteres usado se determina por el valor de la variable de
sistema character_set_results
. Si esta
variable se pone a NULL
, no se realiza ninguna
conversión y el servidor devuelve metadatos usando su conjunto de
caracteres original (el conjunto indicado por
character_set_system
).
Para que el servidor pase los resultados de metadatos con un
conjunto de caracteres no-UTF8, utilícese SET
NAMES
para forzar al servidor a hacer una conversión
del conjunto de caracteres (consulte
Sección 10.3.6, “Conjunto de caracteres y colación de la conexión”), o hacer que el cliente haga
la conversión. Es más eficiente que el cliente haga la
conversión, pero esta opción no está disponible para todos los
clientes.
Si utiliza (por ejemplo) la función USER()
para comparación o asignación dentro de un comando, no se
preocupe. MySQL realiza algunas conversiones automáticas.
SELECT * FROM Table1 WHERE USER() = latin1_column;
Esta sentencia funciona porque los contenidos de
latin1_column
se convierten automáticamente a
UTF8 antes de la comparación.
INSERT INTO Table1 (latin1_column) SELECT USER();
Esta sentencia funciona porque los contenidos de
USER()
se convierten automáticamente a
latin1
antes de la asignación. La conversión
automática no está completamente implementada aún, pero
debería funcionar correctamente en versiones posteriores.
Aunque la conversión automática no está en el estándar SQL, el documento estándar SQL dice que cada conjunto de caracteres es (en términos de caracteres soportados) un “subconjunto” de Unicode. Puesto que es un principio bien conocido que “lo que se aplica a un superconjunto se puede aplicar a un subconjunto”, creemos que una colación para Unicode se puede aplicar para comparaciones con cadenas de caracteres no-Unicode.
Para compatibilidad con MaxDB estos dos comandos son iguales:
CREATE TABLE t1 (f1 CHAR(n
) UNICODE); CREATE TABLE t1 (f1 CHAR(n
) CHARACTER SET ucs2);
En MySQL 5.0, la configuración del conjunto de caracteres se
guarda en ficheros XML, un fichero por conjunto de caracteres.
(Antes de MySQL 4.1, esta información se guardaba en ficheros
.conf
.
ANSI SQL define NCHAR
o NATIONAL
CHAR
como formas de indicar que una columna
CHAR
debe usar algún conjunto de caracteres
predefinido. MySQL 5.0 usa utf8
como su
conjunto de caracteres predefinido. Por ejemplo, estas
declaraciones de tipos de columnas son equivalentes:
CHAR(10) CHARACTER SET utf8 NATIONAL CHARACTER(10) NCHAR(10)
Igual que éstas:
VARCHAR(10) CHARACTER SET utf8 NATIONAL VARCHAR(10) NCHAR VARCHAR(10) NATIONAL CHARACTER VARYING(10) NATIONAL CHAR VARYING(10)
Puede usar
N'
para
crear una cadena de caracteres en el conjunto de caracteres
nacional. Estos dos comandos son equivalentes:
literal
'
SELECT N'some text'; SELECT _utf8'some text';
MySQL soporta más de 70 colaciones para más de 30 conjuntos de
caracteres. Los conjuntos de caracteres y sus colaciones por
defecto se muestran con el comando SHOW CHARACTER
SET
:
+----------+-----------------------------+---------------------+--------+ | Charset | Description | Default collation | Maxlen | +----------+-----------------------------+---------------------+--------+ | big5 | Big5 Traditional Chinese | big5_chinese_ci | 2 | | dec8 | DEC West European | dec8_swedish_ci | 1 | | cp850 | DOS West European | cp850_general_ci | 1 | | hp8 | HP West European | hp8_english_ci | 1 | | koi8r | KOI8-R Relcom Russian | koi8r_general_ci | 1 | | latin1 | ISO 8859-1 West European | latin1_swedish_ci | 1 | | latin2 | ISO 8859-2 Central European | latin2_general_ci | 1 | | swe7 | 7bit Swedish | swe7_swedish_ci | 1 | | ascii | US ASCII | ascii_general_ci | 1 | | ujis | EUC-JP Japanese | ujis_japanese_ci | 3 | | sjis | Shift-JIS Japanese | sjis_japanese_ci | 2 | | hebrew | ISO 8859-8 Hebrew | hebrew_general_ci | 1 | | tis620 | TIS620 Thai | tis620_thai_ci | 1 | | euckr | EUC-KR Korean | euckr_korean_ci | 2 | | koi8u | KOI8-U Ukrainian | koi8u_general_ci | 1 | | gb2312 | GB2312 Simplified Chinese | gb2312_chinese_ci | 2 | | greek | ISO 8859-7 Greek | greek_general_ci | 1 | | cp1250 | Windows Central European | cp1250_general_ci | 1 | | gbk | GBK Simplified Chinese | gbk_chinese_ci | 2 | | latin5 | ISO 8859-9 Turkish | latin5_turkish_ci | 1 | | armscii8 | ARMSCII-8 Armenian | armscii8_general_ci | 1 | | utf8 | UTF-8 Unicode | utf8_general_ci | 3 | | ucs2 | UCS-2 Unicode | ucs2_general_ci | 2 | | cp866 | DOS Russian | cp866_general_ci | 1 | | keybcs2 | DOS Kamenicky Czech-Slovak | keybcs2_general_ci | 1 | | macce | Mac Central European | macce_general_ci | 1 | | macroman | Mac West European | macroman_general_ci | 1 | | cp852 | DOS Central European | cp852_general_ci | 1 | | latin7 | ISO 8859-13 Baltic | latin7_general_ci | 1 | | cp1251 | Windows Cyrillic | cp1251_general_ci | 1 | | cp1256 | Windows Arabic | cp1256_general_ci | 1 | | cp1257 | Windows Baltic | cp1257_general_ci | 1 | | binary | Binary pseudo charset | binary | 1 | | geostd8 | GEOSTD8 Georgian | geostd8_general_ci | 1 | | cp932 | SJIS for Windows Japanese | cp932_japanese_ci | 2 | | eucjpms | UJIS for Windows Japanese | eucjpms_japanese_ci | 3 | +----------+-----------------------------+---------------------+--------+
MySQL tiene dos conjuntos de caracteres Unicode. Puede almacenar texto en unos 650 idiomas usando estos conjuntos de caracteres. Hemos añadido varias colaciones para estos dos nuevos conjuntos, y pronto añadiremos más.
ucs2
(UCS-2 Unicode) colaciones:
mysql> SHOW COLLATION LIKE 'ucs2%'; +--------------------+---------+-----+---------+----------+---------+ | Collation | Charset | Id | Default | Compiled | Sortlen | +--------------------+---------+-----+---------+----------+---------+ | ucs2_general_ci | ucs2 | 35 | Yes | Yes | 1 | | ucs2_bin | ucs2 | 90 | | Yes | 1 | | ucs2_unicode_ci | ucs2 | 128 | | Yes | 8 | | ucs2_icelandic_ci | ucs2 | 129 | | Yes | 8 | | ucs2_latvian_ci | ucs2 | 130 | | Yes | 8 | | ucs2_romanian_ci | ucs2 | 131 | | Yes | 8 | | ucs2_slovenian_ci | ucs2 | 132 | | Yes | 8 | | ucs2_polish_ci | ucs2 | 133 | | Yes | 8 | | ucs2_estonian_ci | ucs2 | 134 | | Yes | 8 | | ucs2_spanish_ci | ucs2 | 135 | | Yes | 8 | | ucs2_swedish_ci | ucs2 | 136 | | Yes | 8 | | ucs2_turkish_ci | ucs2 | 137 | | Yes | 8 | | ucs2_czech_ci | ucs2 | 138 | | Yes | 8 | | ucs2_danish_ci | ucs2 | 139 | | Yes | 8 | | ucs2_lithuanian_ci | ucs2 | 140 | | Yes | 8 | | ucs2_slovak_ci | ucs2 | 141 | | Yes | 8 | | ucs2_spanish2_ci | ucs2 | 142 | | Yes | 8 | | ucs2_roman_ci | ucs2 | 143 | | Yes | 8 | | ucs2_persian_ci | ucs2 | 144 | | Yes | 8 | +--------------------+---------+-----+---------+----------+---------+
utf8
(UTF-8 Unicode) colaciones:
mysql> SHOW COLLATION LIKE 'utf8%'; +--------------------+---------+-----+---------+----------+---------+ | Collation | Charset | Id | Default | Compiled | Sortlen | +--------------------+---------+-----+---------+----------+---------+ | utf8_general_ci | utf8 | 33 | Yes | Yes | 1 | | utf8_bin | utf8 | 83 | | Yes | 1 | | utf8_unicode_ci | utf8 | 192 | | Yes | 8 | | utf8_icelandic_ci | utf8 | 193 | | Yes | 8 | | utf8_latvian_ci | utf8 | 194 | | Yes | 8 | | utf8_romanian_ci | utf8 | 195 | | Yes | 8 | | utf8_slovenian_ci | utf8 | 196 | | Yes | 8 | | utf8_polish_ci | utf8 | 197 | | Yes | 8 | | utf8_estonian_ci | utf8 | 198 | | Yes | 8 | | utf8_spanish_ci | utf8 | 199 | | Yes | 8 | | utf8_swedish_ci | utf8 | 200 | | Yes | 8 | | utf8_turkish_ci | utf8 | 201 | | Yes | 8 | | utf8_czech_ci | utf8 | 202 | | Yes | 8 | | utf8_danish_ci | utf8 | 203 | | Yes | 8 | | utf8_lithuanian_ci | utf8 | 204 | | Yes | 8 | | utf8_slovak_ci | utf8 | 205 | | Yes | 8 | | utf8_spanish2_ci | utf8 | 206 | | Yes | 8 | | utf8_roman_ci | utf8 | 207 | | Yes | 8 | | utf8_persian_ci | utf8 | 208 | | Yes | 8 | +--------------------+---------+-----+---------+----------+---------+
La colación utf8_unicode_ci
está
implementada según el Algoritmo de Colación Unicode (UCA,
Unicode Collation Algorithm ) descrito en
http://www.unicode.org/reports/tr10/. La
colación usa la versión-4.0.0 UCA para el peso de las claves:
http://www.unicode.org/Public/UCA/4.0.0/allkeys-4.0.0.txt.
(La siguiente exposición se basa en
utf8_unicode_ci
, pero también es cierta para
ucs2_unicode_ci
.)
Actualmente, la colación utf8_unicode_ci
tiene soporta sólo parcialmente el Algoritmo de colación
Unicode. Algunos caracteres no están todavía soportados.
Además, la combinacion de marcas no está soportada
completamente. Esto afecta al vietnamita y a algunos idiomas
minoritarios en Rusia como el Udmurt, Tatar, Bashkir, y Mari.
La caractarística más significativa en
utf8_unicode_ci
es que soporta expansiones,
esto es, cuando un carácter resulta igual a una combinación de
otros caracteres. Por ejemplo, en alemán y otros idiomas
'ß
' es igual a 'ss
'.
utf8_general_ci
es una colación heredada que
no soporta expansiones. Sólo puede hacer comparaciones entre
caracteres uno a uno. Esto significa que las comparaciones para
colaciones utf8_general_ci
son más rápidas,
pero ligeramente menos correctas, que las comparaciones en
utf8_unicode_ci
).
Por ejemplo, las siguientes ecuaciones funcionan tanto en
utf8_general_ci
como en
utf8_unicode_ci
:
Ä = A Ö = O Ü = U
En cambio, esto es cierto para
utf8_general_ci
:
ß = s
Minentras que para utf8_unicode_ci
es cierta
la siguiente:
ß = ss
Colaciones específicas de idiomas para el conjunto de
caracteres utf8
están implementadas sólo si
la ordenación con utf8_unicode_ci
no
funciona bien para un idioma. Por ejemplo,
utf8_unicode_ci
funciona bien para alemán y
francés, así que no es necesario crear colaciones
utf8
especiales para estos dos idiomas.
utf8_general_ci
también es satisfactorio
para alemán y francés, excepto que 'ß
' es
igual a 's
', y no a 'ss
'.
Si esto es aceptable para su aplicación, debe usar
utf8_general_ci
porque es más rápido. En
caso contraro , use utf8_unicode_ci
porque es
más preciso.
utf8_swedish_ci
, como otras colaciones
utf8
específicas de un idioma, deriva de
utf8_unicode_ci
con reglas adicionales de
idioma. Por ejemplo, en sueco, la siguiente comparación es
cierta, lo que no esperaría un alemán o un francés:
Ü = Y < Ö
Las colaciones utf8_spanish_ci
y
utf8_spanish2_ci
se corresponden con español
moderno y español tradicional respectivamente. En ambas
colaciones , 'ñ
' es una letra independiente,
entre 'n
' y 'o
'. Además,
para español tradicional 'ch
' es una letra,
ordenada entre 'c
' y d
, y
'll
' es una letra que se coloca entre
'l
' y 'm
'
Los conjuntos de caracteres para Europa Occidental cubren la mayoría de lenguas de Europa Occidental como francés, español, catalán, vasco, protugués, italiano, albano, alemán, holandés, sueco, noruego, finlandés, feroés, islandés, irlandés, escocés e inglés.
ascii
(US ASCII) colaciones:
ascii_bin
ascii_general_ci
(por defecto)
cp850
(DOS Europa Occidental) colaciones:
cp850_bin
cp850_general_ci
(por defecto)
dec8
(DEC Europa Occidental) colaciones:
dec8_bin
dec8_swedish_ci
(por defecto)
hp8
(HP Europa Occidental) colaciones:
hp8_bin
hp8_english_ci
(por defecto)
latin1
(ISO 8859-1 Europa Occidental)
colaciones:
latin1_bin
latin1_danish_ci
latin1_general_ci
latin1_general_cs
latin1_german1_ci
latin1_german2_ci
latin1_spanish_ci
latin1_swedish_ci
(por defecto)
latin1
es el conjunto de caracteres por
defecto. La colación latin1_swedish_ci
es la colación por defecto que probablemente usan la
mayoría de clientes MySQL. Se dice frecuentemente que está
basado en las reglas de colación sueca/finlandesa, pero hay
suecos y finlandeses que no están de acuerdo con esta
afirmación.
Las colaciones latin1_german1_ci
y
latin1_german2_ci
están basadas en los
estándars DIN-1 y DIN-2, mientras DIN significa
Deutsches Institut für Normung (el
equivalente alemán de ANSI). DIN-1 es el diccionario de la
colación y DIN-2 son las "páginas amarillas" de la
colación.
latin1_german1_ci
(diccionario)
reglas:
Ä = A Ö = O Ü = U ß = s
latin1_german2_ci
(páginas
amarillas) reglas:
Ä = AE Ö = OE Ü = UE ß = ss
En la colación latin1_spanish_ci
,
'ñ
' es una letra independiente, entre
'n
' y 'o
'.
macroman
(Mac Europa Occidental)
colaciones:
macroman_bin
macroman_general_ci
(por defecto)
swe7
(7bit Sueca) colación:
swe7_bin
swe7_swedish_ci
(por defecto)
También proveemos algún soporte para conjuntos de caracteres usados en la República Checa, Eslovaquia, Hungría, Romania, Eslovenia, Croacia y Polonia.
cp1250
(Windows Europa Central)
colaciones:
cp1250_bin
cp1250_croatian_ci
cp1250_czech_cs
cp1250_general_ci
(por defecto)
cp852
(DOS Europa Central) colaciones:
cp852_bin
cp852_general_ci
(por defecto)
keybcs2
(DOS Kamenicky Checo-Eslovaco)
colaciones:
keybcs2_bin
keybcs2_general_ci
(por defecto)
latin2
(ISO 8859-2 Europa Central)
colaciones:
latin2_bin
latin2_croatian_ci
latin2_czech_cs
latin2_general_ci
(por defecto)
latin2_hungarian_ci
macce
(Mac Europa Central) colaciones:
macce_bin
macce_general_ci
(por defecto)
armscii8
(ARMSCII-8 Armenia) colaciones:
armscii8_bin
armscii8_general_ci
(por defecto)
cp1256
(Windows Arabiga) colaciones:
cp1256_bin
cp1256_general_ci
(por defecto)
geostd8
(GEOSTD8 Georgia) colaciones:
geostd8_bin
geostd8_general_ci
(por defecto)
greek
(ISO 8859-7 Grecia) colaciones:
greek_bin
greek_general_ci
(default)
hebrew
(ISO 8859-8 Hebrew) collations:
hebrew_bin
hebrew_general_ci
(por defecto)
latin5
(ISO 8859-9 Turquía) colaciones:
latin5_bin
latin5_turkish_ci
(por defecto)
Los conjuntos de caracteres bálticos cubren estonio, letón, y lituano. Hay dos conjuntos de caracteres bálticos soportados en la actualidad:
cp1257
(Windows Báltico) colaciones:
cp1257_bin
cp1257_general_ci
(por defecto)
cp1257_lithuanian_ci
latin7
(ISO 8859-13 Báltico) colaciones:
latin7_bin
latin7_estonian_cs
latin7_general_ci
(por defecto)
latin7_general_cs
Estos son los conjuntos de caracteres cirílicos y colaciones para usar con bielorruso, búlgaro, ruso y ucraniano.
cp1251
(Windows cirílico) colaciones:
cp1251_bin
cp1251_bulgarian_ci
cp1251_general_ci
(por defecto)
cp1251_general_cs
cp1251_ukrainian_ci
cp866
(DOS Ruso) colaciones:
cp866_bin
cp866_general_ci
(por defecto)
koi8r
(KOI8-R Relcom Rusia) colaciones:
koi8r_bin
koi8r_general_ci
(por defecto)
koi8u
(KOI8-U Ukrania) colaciones:
koi8u_bin
koi8u_general_ci
(por defecto)
Los conjuntos de caracteres asiáticos que soportamos incluyen chino, japonés, koreano y thai. Esto puede ser complicado. Por ejemplo, los conjuntos chinos deben permitir miles de caracteres distintos.
big5
(Big5 chino tradicional) colaciones:
big5_bin
big5_chinese_ci
(por defecto)
cp932
(SJIS para Windows japonés)
collations:
cp932_bin
cp932_japanese_ci
(por defecto)
eucjpms
(UJIS para Windows japonés)
colaciones:
eucjpms_bin
eucjpms_japanese_ci
(por defecto)
euckr
(EUC-KR Koreano) colaciones:
euckr_bin
euckr_korean_ci
(por defecto)
gb2312
(GB2312 chino simplificado)
colaciones:
gb2312_bin
gb2312_chinese_ci
(por defecto)
gbk
(GBK chino simplificado) colaciones:
gbk_bin
gbk_chinese_ci
(por defecto)
sjis
(Shift-JIS japonés) colaciones:
sjis_bin
sjis_japanese_ci
(por defecto)
tis620
(TIS620 Thai) colaciones:
tis620_bin
tis620_thai_ci
(por defecto)
ujis
(EUC-JP japonés) colaciones:
ujis_bin
ujis_japanese_ci
(por defecto)
Ésta es una traducción del manual de referencia de MySQL, que puede encontrarse en dev.mysql.com. El manual de referencia original de MySQL está escrito en inglés, y esta traducción no necesariamente está tan actualizada como la versión original. Para cualquier sugerencia sobre la traducción y para señalar errores de cualquier tipo, no dude en dirigirse a mysql-es@vespito.com.