Capítulo 10. Soporte de conjuntos de caracteres
Anterior |  | Siguiente

## Capítulo 10. Soporte de conjuntos de caracteres

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.

## 10.1. Conjuntos de caracteres y colaciones en general

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.

## 10.2. Conjuntos de caracteres y colaciones en MySQL

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).

## 10.3. Determinar el conjunto de caracteres y la colación por defecto

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.

### 10.3.1. Conjunto de caracteres y colación del servidor

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.

### 10.3.2. Conjuntos de caracteres y colaciones de la base de datos

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 DATABASE nombre_de_base_de_datos
        [[DEFAULT] CHARACTER SET nombre_de_conjunto_de_caracteres]
        [[DEFAULT] COLLATE nombre_de_colación]

    ALTER DATABASE nombre_de_base_de_datos
        [[DEFAULT] CHARACTER SET nombre_de_conjunto_de_caracteres]
        [[DEFAULT] COLLATE nombre_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 `X`` como `COLLATE `Y`` se especifican, entonces el conjunto de caracteres es `X` y la colación `Y`.

- Si `CHARACTER SET `X`` se especifica sin `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`.

### 10.3.3. Conjunto de caracteres y colación de tabla

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 TABLE nombre_de_tabla (lista_de_columnas)
        [DEFAULT CHARACTER SET nombre_de_conjunto_de_caracteres [COLLATE nombre_de_colación]]

    ALTER TABLE nombre_de_tabla
        [DEFAULT CHARACTER SET nombre_de_conjunto_de_caracteres] [COLLATE nombre_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 `X`` y `COLLATE `Y`` , entonces el conjunto de caracteres es `X` y la colación `Y`.

- Si se especifica `CHARACTER SET `X`` sin `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.

### 10.3.4. Conjunto de caracteres y colación de columnas

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 SET nombre_de_conjunto_de_caracteres [COLLATE nombre_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 `X`` y `COLLATE `Y`` , entonces el conjunto de caracteres es `X` y la colación `Y`.

- Si se especifica `CHARACTER SET `X`` sin `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.

### 10.3.5. Ejemplos de asignación de conjunto de caracteres y colación

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`.

### 10.3.6. Conjunto de caracteres y colación de la conexión

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 SET nombre_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 '`x`'` es equivalente a estos tres comandos:

    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;

### 10.3.7. Conjunto de caracteres y colación de columnas “carácter”

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' [COLLATE nombre_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 '`cadena_de_texto`'`, la cadena de caracteres tiene el conjunto de caracteres y colación definida por las variables de sistema `character_set_connection` y `collation_connection`.

La expresión `_`nombre_de_conjunto_de_caracteres`` se llama formalmente introductor. Le dice al parser: “la siguiente cadena de caracteres utiliza el 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'`literal`'` y `0x`nnnn``), y antes de `?` (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 `Y`` , entonces el conjunto de caracteres es `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.

### 10.3.8. Usar `COLLATE` en sentencias 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;

### 10.3.9. Precedencia de la cláusula `COLLATE`

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)

### 10.3.10. Operador `BINARY`

El operador `BINARY` es una abreviación de la cláusula `COLLATE`. `BINARY '`x`'` es equivalente a `'`x`' COLLATE `y``, donde `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;

### 10.3.11. Casos especiales en los que determinar la colación es complicado

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.

### 10.3.12. A cada colación un conjunto de caracteres correcto

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'

### 10.3.13. Un ejemplo del efecto de una colación

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.

## 10.4. Efectos del soporte de conjuntos de caracteres

Esta sección describe operaciones que tienen en cuenta información sobre el conjunto de caracteres en MySQL 5.0.

### 10.4.1. Cadenas de caracteres de resultado

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(`X`)` devuelve una cadena de caracteres con un conjunto de caracteres y colación iguales a las de `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 `X`` explícito, usa `X`.

- Si hay un `COLLATE `X`` y `COLLATE `Y`` explícitos, muestra un error.

- 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 `X` END`, la colación resultante es `X`. 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()`.

### 10.4.2. `CONVERT()`

`CONVERT()` proporciona un modo de convertir datos entre distintos conjuntos de caracteres. La sintaxis es:

    CONVERT(expr USING transcoding_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.

### 10.4.3. `CAST()`

Puede usar `CAST()` para convertir una cadena de caracteres a un conjunto de caracteres distinto. La sintaxis es:

    CAST(cadena_de_caracteres AS tipo_de_datos CHARACTER SET nombre_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.

### 10.4.4. Sentencias `SHOW`

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.)

Consulte Sección 13.5.4.3, “Sintaxis de `SHOW COLUMNS`”.

## 10.5. Soporte Unicode

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.

## 10.6. UTF8 para metadatos

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.

## 10.7. Compatibilidad con otros SGBDs (Sistemas gestores de bases de datos)

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);

## 10.8. Formato del nuevo fichero de conjunto de caracateres

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`.

## 10.9. Conjunto de caracteres nacional

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'`literal`'` para crear una cadena de caracteres en el conjunto de caracteres nacional. Estos dos comandos son equivalentes:

    SELECT N'some text';
    SELECT _utf8'some text';

## 10.10. Conjuntos de caracteres y colaciones que soporta MySQL

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

### 10.10.1. Conjuntos de caracteres Unicode

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`'

### 10.10.2. Conjuntos de caracteres de Europa occidental

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)

### 10.10.3. Conjuntos de caracteres de Europa central

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)

### 10.10.4. Conjuntos de caracteres del sur de Europa y de Oriente Medio

- `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)

### 10.10.5. Conjuntos de caracteres bálticos

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`

### 10.10.6. Conjuntos de caracteres cirílicos

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)

### 10.10.7. Conjuntos de caracteres asiáticos

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.

Anterior |  | Siguiente
Capítulo 9. Estructura de lenguaje | Inicio | Capítulo 11. Tipos de columna