Índice
COLLATE
em Várias Partes de uma Consulta SQLCOLLATE
BINARY
Melhora do tratamento dos conjuntos de caracteres é um do recursos adicionado ao MySQL na versão 4.1. Este capítulo explica:
O que são conjuntos de caracteres e collations
O sistema padrão de multi níveis
A nova sintaxe no MySQL 4.1
Funções e operações afetadas
O signifcado individual de cada conjunto de caracter e collation
Os recursos descritos aqui estão como implementados no MySQL 4.1.1. (MySQL 4.1.0 possui alguns, mas não todos destes recuros, e alguns deles estão implementados de forma diferente.)
Um conjunto de caracters é um conjunto de simbolos e códigos. Uma collation é um conjunto de regras para comparação de caracteres em um conjunto de caracteres. Vamos deixar a distinção clara com um exemplo de um conjunto de caracteres imaginário.
Suponha que temos um alfabeto com quatro letras:
‘A
’,
‘B
’,
‘a
’,
‘b
’. Damos um número a cada letra:
‘A
’ = 0,
‘B
’ = 1,
‘a
’ = 2,
‘c
’ = 3. A letra
‘A
’ é o símbolo, o número 0 é o
código para
‘A
’, e a combinação de todas as
quatro letra e seus códigos é um conjunto
de caracteres.
Agora suponha que desejamos comparar dusa strings,
‘A
’ e
‘B
’. O modo mais simples de se
fazer isto é olhar o código --- 0 para
‘A
’ e 1 para
‘B
’ --- e como 0 é menor que 1,
dezemos que ‘A
’ é menor que
‘B
’. Agora, o que fizemos foi
apenas aplicar um collation a nosso conjunto de caracteres. A
collation é um conjunto de regras (apenas um regra neste caso):
``compara os códigos''. Chamamos isto a mais simples de todas as
collations possíveis como um collation
binária
.
Mas e se você dissesse que letras mínusculas e maiúsculas são
equivalentes? Então haveriam pelo menos duas regras: (1) tratar
as letras minúsculas ‘a
’ e
‘b
’ como equivalentes a
‘A
’ e
‘B
’; (2) e então comparar os
códigos. Chamamos isto de collation caso
insensitivo. É um pouco mais complexo do que collation
binária.
Na vida real, a maioria dos conjuntos de caracteres possuem muitos
caracteres: não apenas ‘A
’ e
‘B
’ mas todo o alfabeto, algumas
vezes alfabetos múltiplos ou sistemas de escritas ocidentais com
milhares de caracteres, junto com muitos símbolos especiais e
sinais de pontuação. Em geral as collations também possuem
diversas regras: não apenas caso insensitivo mas acentos
insensitivos e mapeamento de múltiplos caracteres (como a regra
de que ‘Ö
’ =
'OE
' em uma das duas collations alemãs).
O MySQL 4.1 pode fazer as seguintes coisas para você:
Armazena a string usando um variedade de conjunto de caracteres
Compara strings usando uma variedade de collations
Mistura strings com diferentes conjuntos de caracteres ou collations no mesmo servidor, o mesmo banco de dados ou a mesma tabela
Permite a especificação de conjunto de caracteres e collations em qualquer nível
A este respeito, o MySQL 4.1 não só é mais flexível que o MySQL 4.0, mas também está bem a frente de outros SGBDs. No entanto, para usar os novos recursos efetivamente, você precisará aprender quais conjuntos de caracteres e collations estão disponíveis, como alterar os seus padrões e o que os vários operadores de string fazem como ele.
Um conjunto de caracter sempre tem pelo menos uma collation. Ele pode ter diversas collations.
Por exemplo, conjunto de caracteres latin1
(``ISO-8859-1 West European'') tem os seguintes collations:
Collation | Significado |
latin1_bin | Binario de acordo com a codificação latin1 |
latin1_danish_ci | Dinamarquês/Norueguês |
latin1_german1_ci | Alemão DIN-1 |
latin1_german2_ci | Alemão DIN-2 |
latin1_swedish_ci | Sueco/Finnish |
latin1_general_ci | Multilingua |
Notas:
Dois conjuntos de caracteres diferentes não podem ter a mesma collation.
Cada conjunto de caracteres tem uma collation que é a
collation padrão. Por exemplp, o
collation padrão para latin1
é
latin1_swedish_ci
.
Perceba que existe uma convenção para nomes de collations: Elas
iniciam com o nome do conjunto de caracteres com o qual elas são
associadas, eles normalmente incluem um nome de linguagem e
finalizam com _ci
(caso insensitivo),
_cs
(caso sensitivo), ou
_bin
(binario).
COLLATE
em Várias Partes de uma Consulta SQLCOLLATE
BINARY
Existem configurações padrões para conjuntos de caracteres e collations em quatro níveis: servidor, banco de dados, tabela, conexão. A seguinte descrição pode parecer complexa, mas será encontrada na prática que os padrões em multi-níveis levam a resultados naturais e óbvios.
O MySQL Server possui um conjunto de caracteres de servidor e collation de servidor que não podem ser nulos.
O MySQL determina o conjunto de caracteres e collations de servidor desta forma:
De acordo com as opções de configuração em efeito quando o servidor é iniciado.
Neste nível, a decisão é simples. O conjunto de caracteres e
collations do servidor dependem das opções que você usa
quando você inicia o mysqld
. Você pode usar
--default-character-set=character_set_name
para
o conjunto de caracteres, e junto com isto você pode adcionar
--default-collation=collation_name
para a
collation. Se você não especificar um conjunto de caracteres,
é o mesmo que utilizar
--default-character-set=latin1
. Se você
especificar apenas um conjunto de caracteres (por exemplo,
latin1
) mas não uma collation, é o mesmo
que usar --default-charset=latin1
--collation=latin1_swedish_ci
pois
latin1_swedish_ci
é a collation padrão para
latin1
. Desta forma, os três comando
seguintees todos têm o mesmo efeito:
shell>mysqld
shell>mysqld --default-character-set=latin1
shell>mysqld --default-character-set=latin1
--default-collation=latin1_swedish_ci
Um modo de o conjunto é recompilando. Se você quiser alterar o
conjunto de caracteres e collation padrões na construção dos
fontes, utilize: --with-character-set
e
--with-collation
como argumento para
configure
. Por exemplo:
shell> ./configure --with-character-set=latin1
ou
shell> ./configure --with-character-set=latin1
--with-collation=latin1_german1_ci
Tanto o mysqld
quanto o
configure
verificam que a combinação
conjunto de caracteres/collations é válida. Cada programa
exibe um mensagem de erro e termina se a combinação não for
válida.
Todo banco de dados tem um conjunto de caracteres de banco de
dados e uma collatio de banco de dados, que não podem ser
nulos. Os comandos CREATE DATABASE
e
ALTER DATABASE
agora possuem cláusulas
opcionais para especificarem o collation e conjunto de
caracteres de banco de dados:
CREATE DATABASE db_name [DEFAULT CHARACTER SET character_set_name [COLLATE collation_name]] ALTER DATABASE db_name [DEFAULT CHARACTER SET character_set_name [COLLATE collation_name]]
Exemplo:
CREATE DATABASE db_name DEFAULT CHARACTER SET latin1 COLLATE latin1_swedish_ci;
O MySQL escolhe o conjunto de caracteres e collations do banco de dados desta forma:
Se CHARACTER SET X
e COLLATE
Y
foram especificados, então o conjunto de
caracteres é X
e a é collation
Y
.
Se CHARACTER SET X
foi especificado sem
COLLATE
, então o conjunto de caracteres
é X
e a collation é o padrão.
Senão utiliza o conjunto de caracteres e a collation de servidor.
A sintaxe CREATE DATABASE ... DEFAULT CHARACTER SET
...
do MySQL é análoga a sintaxe CREATE
SCHEMA ... CHARACTER SET ...
do padrão SQL. Por isto,
é possível criar bancos de dados com com conjunto de
caracteres e collations diferentes, no mesmo servidor MySQL.
O conjuto de caracteres e collations do banco de dados são
usados como valores padrões se o conjunto de caracteres e a
collation de tabela não forem especificados nas instruções
CREATE TABLE
. Eles não possuem nenhum outro
propósito.
Toda tabela tem um conjunto de caracteres e collations de
tabela, que não pode ser nulo. As instruções CREATE
TABLE
e ALTER TABLE
agora possuem
um cláusula opcional para especificar o conjunto de caracteres
e collation de tabela:
CREATE TABLE table_name ( column_list ) [DEFAULT CHARACTER SET character_set_name [COLLATE collation_name]] ALTER TABLE table_name [DEFAULT CHARACTER SET character_set_name] [COLLATE collation_name]
Exemplo:
CREATE TABLE t1 ( ... ) DEFAULT CHARACTER SET latin1 COLLATE latin1_danish_ci;
O MySQL escolhe o conjunto de caracteres e collation de tabela desta forma:
Se CHARACTER SET X
e COLLATE
Y
forem especificados, então o conjunto de
caracteres é X
e collation é
Y
.
Se CHARACTER SET X
foi especificado sem
COLLATE
, então o conjunto de caracteres
é X
e o collation é o padrão.
Senão, o conjunto de caracteres e collation são os padrões.
O conjunto de caracteres e collation de tabela são usado como valores padrões, se o conjunto de caracteres e collation de colunas não são especificados nas definições de colunas individuais. O conjunto de caracteres e collation de tabelas são extensões MySQL; não há nada deste tipo na padrão SQL.
Toda coluna ``caracter'' (isto é, uma colua do tipo
CHAR
, VARCHAR
, ou
TEXT
) tem um conjunto de caracteres e
collation de coluna, que não pode ser nulo. A sintaxe de
definição de coluna agora possui uma cláusula opcional para
especificar o conjunto de caracteres e collation:
column_name {CHAR | VARCHAR | TEXT} (column_length) [CHARACTER SET character_set_name [COLLATE collation_name]]
Exemplo:
CREATE TABLE Table1 ( column1 VARCHAR(5) CHARACTER SET latin1 COLLATE latin1_german1_ci );
O MySQL escolhe o conjunto de caracteres e collation de coluna desta forma:
Se CHARACTER SET X
e COLLATE
Y
forem especificados, então o conjunto de
caracteres é X
e collation é
Y
.
Se CHARACTER SET X
foi especificado sem
COLLATE
, então o conjunto de caracteres
é X
e o collation é o padrão.
Senão, o conjunto de caracteres e collation são os padrões.
As cláusulas CHARACTER SET
e
COLLATE
são do padrão SQL.
Os seguintes exemplos mostram como o MySQL determina valores de conjunto de caracteres e collations padrões.
Exemplo 1: Definição de Tabela + Coluna
CREATE TABLE t1 ( c1 CHAR(10) CHARACTER SET latin1 COLLATE latin1_german1_ci ) DEFAULT CHARACTER SET latin2 COLLATE latin2_bin;
Aqui você tem uma coluna com um conjunto de caracteres
latin1
e um collation
latin1_german1_ci
. A definição é
explicita, assim ele é direto. Note que não há problemas em
armazenar uma coluna latin1
em uma tabela
latin2
.
Example 2: Definição de Tabela + Coluna
CREATE TABLE t1 ( c1 CHAR(10) CHARACTER SET latin1 ) DEFAULT CHARACTER SET latin1 COLLATE latin1_danish_ci;
Desta vez temos uma coluna com um conjunto de caracteres
latin1
e uma collation padrão. Agora, embora
possa parecer natural, a collation padrão é tomada do nível
de tabela. Como a collation padrão para
latin1
é sempre
latin1_swedish_ci
, a coluna
c1
terá uma collation
latin1_swedish_ci
(e não
latin1_danish_ci
).
Exemplo 3: Definição de Tabela + Coluna
CREATE TABLE t1 ( c1 CHAR(10) ) DEFAULT CHARACTER SET latin1 COLLATE latin1_danish_ci;
Temos uma coluna com um conjunto de caracteres padrão e uma
collation padrão. Nesta circunstância, o MySQL olha para o
nível de tabela para determinar o conjunto de caracteres e
collation de coluna. Assim o conjunto de caracteres para colune
c1
é latin1
e sua
collation é latin1_danish_ci
.
Exemplo 4: Definição de Banco de Dados + Tabela + Coluna
CREATE DATABASE d1 DEFAULT CHARACTER SET latin2 COLLATE latin2_czech_ci; USE d1; CREATE TABLE t1 ( c1 CHAR(10) );
Criamos uma coluna sem especificar seu conjunto de caracteres e
collation. Também não especificamos um conjunto de caracteres
e uma collation na nível de tabela. Nestas circubntâncias, o
MySQL olha para o nível de banco de dados para a
determinação. (A configuração do banco de dados se torna a
configuração da tabela e então a configuração da coluna).
Assim o conjunto de caracteres para coluna c1
é latin2
e sua collation é
latin2_czech_ci
.
Toda conexão tem o seu conjunto de caracteres e collation, que não podem ser nulos. Esistem atualmente dois conjuntos de caracteres de conexão, que chamamos ``connection/literals'' e ``connection/results'' quando é necessário distingui-los.
Considere o que é uma ``conexão'': é o que você faz quando conecta ao servidor. O cliente envia instruções SQL, como consultas, pela conexão com o sevidor. O servidor envia respostas, como resultados, pela conexão de volta para o cliente. Isto leva a diversas questões, tal como: (a) em qual conjunto de caracteres está uma consulta quando ela deixa o cliente? (b) em qual conjunto de caracteres o servidor deve traduzir uma consulta após recebê-la? (c) para qual conjunto de caracteres o servidor deve traduzir antes de enviar o resultado ou mensagem de erros de volta para o cliente? Você pode fazer um ajuste fino das configurações para isto, ou você pode depender dos padrões (neste caso, você pode ignorar esta seção).
Existem suas instruções que afetam o conjunto de caracteres da conexão:
SET NAMES character_set_name SET CHARACTER SET character_set_name
SET NAMES
indica o que está na instrução
SQL que o cliente envia. Assim, SET NAMES
cp1251
diz ao servidor que ``futuras mensagens vindas
do cliente estarão no conjunto de caracteres
cp1251
'' e o servidor está livre para
traduzir para seu próprio conjunto de caracteres, se
apropriado.
SET CHARACTER SET
indica o que está na
instrução SQL que o cliente envia, e também o que está no
resultado que o servidor envia de volta para o cliente. Assim,
SET CHARACTER SET
inclui SET
NAMES
, e também especifica qual conjunto de
caracteres o valor da coluna terá se, por exempo, você usar
uma instrução SELECT
.
EXEMPLO: Suponha que column1
é definido como
CHAR(5) CHARACTER SET latin2
. Se você não
utilizar SET CHARACTER SET
, então para
SELECT column1 FROM t
o servidor enviará de
volta todos os valores para column1
usando o
conjunto de caracteres latin2
. Se por outro
lado você usar SET CHARACTER SET latin1
então o servidor, antes de enviar de volta, converterá os
valores latin2
para
latin1
. Tal conversão é lenta e poder ter
perdas.
Quando você executa SET NAMES
ou
SET CHARACTER SET
, você também está
alterando a ``collation da conexão''. No entanto a collation da
conexão existe apenas para consistência. Normalmente o seu
valor não importa.
Com o cliente mysql
, não é necessário
executar SET NAMES
todas as vezes que você
inicá-lo. Você pode adicionar a opção
--default-character-set-name
a sua linha de
instrução do mysql
, ou em seu arquivo de
opção. Por exemplo, a seguinte configuração do arquivo de
opção irá alterar o conjunto de caracteres da conexão cada
vez que você executar mysql
:
[mysql] default-character-set-name=character_set_name
Todo caracter de uma string literal tem um conjunto de caracteres e collation, que podem ser nulos.
Um caracter de uma string literal pode ter um introdutor de
conjunto de caracteres opcional e cláusula
COLLATE
:
[_character_set_name]'string' [COLLATE collation_name]
Exemplos:
SELECT 'string'; SELECT _latin1'string'; SELECT _latin1'string' COLLATE latin1_danish_ci;
A instrução simples SELECT 'string'
usa o
conjunto de caracteres da conexão/literal.
A expressão _character_set_name
é
formalmente chamada um introdutor. Ele diz
ao analisador que ``a string que ele vai seguir está no
conjunto de caracteres X
.'' Como isto tem
confundido as pessoas no passado, enfatizamos que um introdutor
não faz qualquer conversão, ele simplesmente um sinal que não
altera o valor da string. Um introdutor também é permitido
antes de uma notação de um literal hexa padrão e um literal
hexa numérico (x'literal'
e
0xnnnn
), e antes de ?
(substituição de parâmetros ao usar intruções preparadas
dentro de uma interface de linguagem de programação).
Exemplos:
SELECT _latin1 x'AABBCC'; SELECT _latin1 0xAABBCC; SELECT _latin1 ?;
O MySQL determina um conjunto de caracteres e collation de literal desta forma:
Se _X
e COLLATE Y
forma especificados então o conjunto de caracteres do
literal é X
e o collation do literal é
Y
Se _X
é especificado mas
COLLATE
não é especificado, então o
conjunto de caracteres do literal é X
e
a collation do literal é a collation padrão do
X
De outra forma, o conjunto de caracteres e collation é o da conexão/literal.
Exemplos:
Uma string com o conjunto de caracteres
latin1
e collation
latin1_german1_ci
.
SELECT _latin1'Müller' COLLATE latin1_german1_ci;
Uma string com conjunto de caracteres
latin1
e e sua collation padrão, isto
é, latin1_swedish_ci
:
SELECT _latin1'Müller';
Uma string com o conjunto de caracteres e a collation da conexão/literal:
SELECT 'Müller';
Introdutores de conjunto de caracteres e a cláusula
COLLATE
são implementados de acordo com as
especificações do padrão SQL.
Com a cláusula COLLATE
você pode
sobrescrever o padrão da collation, qualquer que seja ele, para
comparação. COLLATE
pode ser usada em
várias partes da consulta SQL. Aqui estão alguns exemplos:
Com ORDER BY
:
SELECT k FROM t1 ORDER BY k COLLATE latin1_german2_ci;
Com AS
:
SELECT k COLLATE latin1_german2_ci AS k1 FROM t1 ORDER BY k1;
Com GROUP BY
:
SELECT k FROM t1 GROUP BY k COLLATE latin1_german2_ci;
Com aggregate functions:
SELECT MAX(k COLLATE latin1_german2_ci) FROM t1;
Com DISTINCT
:
SELECT DISTINCT k COLLATE latin1_german2_ci FROM t1;
Com WHERE
:
SELECT * FROM t1 WHERE _latin1 'Müller' COLLATE latin1_german2_ci = k;
Com HAVING
:
SELECT k FROM t1 GROUP BY k HAVING k = _latin1 'Müller' COLLATE latin1_german2_ci;
A cláusula COLLATE
tem alta precedência
(maior que ||), então a expressão
x || y COLLATE z
é equivalente a:
x || (y COLLATE z)
O operador BINARY
é uma atalho para uma
cláusula COLLATE
. Por exemplo,
BINARY 'x'
é equivalente a 'x'
COLLATE y
, onde y
é o nome de uma
collation binária apropriada. Por exemplo, assumindo que a
coluna a
é do conjunto de caracteres
latin1
, estas duas consultas têm o mesmo
efeito:
SELECT * FROM t1 ORDER BY BINARY a; SELECT * FROM t1 ORDER BY a COLLATE latin1_bin;
Nota: Todo conjunto de caracteres tem um collation binário.
Na grande maioria das consultas, é obvio qual collation que o
MySQL usa para resolver uma operação de comparação. Por
exemplo, nos seguintes casos deve estar claro que a
collationserá ``a collation de coluna da coluna
x
'':
SELECT x FROM T ORDER BY x; SELECT x FROM T WHERE x = x; SELECT DISTINCT x FROM T;
No entanto, quando múltiplos operandos estão envolvidos, pode haver ambiguidade. Por exemplo:
SELECT x FROM T WHERE x = 'Y';
Esta consulta deve usar a collation de coluna
x
, ou da string literal
'Y'
?
O padrão SQL resolve tal questão usando o que se costuma
chamar real ``coercibilidade''. A essência é: Como
x
e 'Y'
tem collation,
qual collation toma precedência? É complexo, mas estas regras
cuidariam da maioria das situações:
Uma cláusula COLLATE
explicita tem
precedência 4
Uma concatenação de duas strings com diferentes collations tem precedência 3.
Uma collation de coluna tem precedência 2.
Uma collation de literal tem precedência 1.
Estas regras resolvem ambiguidades da seguinte forma:
Use a collation com a maior precedência.
Se ambos os lados tiverem a mesma precedência, então terá um erro se a collation não são as mesmas.
Exemplos:
column1 = 'A' | Usa a collation de column1 |
column1 = 'A' COLLATE x | Usa a collation de 'A' |
column1 COLLATE x = 'A' COLLATE y | Error |
Lembramos que cada conjunto de caracteres tem um ou mais
collation, e cada collation é associada com um e apenas um
conjunto de caracteres. Consequentemente, a seguinte instrução
causa um mensagem de erro porque a collation
latin2_bin
não é permitida com o conjunto
de caracteres latin1
:
mysql> SELECT _latin1 'x' COLLATE latin2_bin;
ERROR 1251: COLLATION 'latin2_bin' is not valid
for CHARACTER SET 'latin1'
Suponha que a coluna X
na tabela
T
possui estes valores na coluna
latin1
:
Muffler Müller MX Systems MySQL
E suponha que os valores da coluna são retornados usando a seguinte instrução:
SELECT X FROM T ORDER BY X COLLATE collation_name;
A ordem resultante dos valores para diferentes collation é mostrado nesta tabela:
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 |
A tabela é um exemplo que mostra que mostra qual seria o efeito
se usassemos collation diferentes em um cláusula ORDER
BY
. O caracter que está causando o problema neste
exemplo é o U com dois pontos sobre ele, que os Alemães chamam
de U-umlaut, mas nós chamamos de U-diaeresis.
A primeira coluna mostra o resultado da
SELECT
usando as regras de collation
Suéco/Finlandês, que diz que U-diaeresis ordena com Y.
A segunda coluna mostra o resultado da SELECT
usando as regras Almão DIN-1, que diz que U-diaeresis ordena
com U.
A terceira coluna mostra o resultado da
SELECT
usando as regras Almão DIN-2, que diz
que U-diaeresis ordena com UE.
Três collation diferentes, três resultados diferentes. Isto é o que o MySQL está aqui para tratar. Usando a collation apropriada, você pode esclher a ordem que você deseja.
Esta seção descreve operacões que pegam a informação do conjunto de caracteres dentro da conta agora.
O MySQL tem muitos operadores e funções que retornam um string. Esta seção responde a questão: Qual é o conjunto de caracteres e collation de um certa string?
Para funções simples que pegam uma string de entrada e
retornam uma string de resultado como saída, a saída do
conjunto de caracteres e collation são as mesmas da entrada
principal. Por exemplo, UPPER(X)
retorna uma
string cuja string de caracter e collation são os mesmo de
X
. O mesmo se aplica a:
INSTR()
, LCASE()
,
LOWER()
, LTRIM()
,
MID()
, REPEAT()
,
REPLACE()
, REVERSE()
,
RIGHT()
, RPAD()
,
RTRIM()
, SOUNDEX()
,
SUBSTRING()
, TRIM()
,
UCASE()
, UPPER()
. (Note
também: a função REPLACE()
, diferente de
todas as outras funções, ignora a collation da string de
entrada e realiza uma comparação de caso-insensitivo todas as
vezes.)
Para operações que combinam múltiplas entradas de string e retornam uma única saída de string, As ``regras de agregamento'' do SQL-99 se aplicam. Eles são:
Se ocorrer um COLLATE X
explicito, então
use X
Se ocorrerem COLLATE X
e COLLATE
Y
explicitos, então erro
Senão, se todas as collations são X
,
então use X
Senão, o resultado não possui collation
Por exemplo, com CASE ... WHEN a THEN b WHEN b THEN c
COLLATE X END
, a collation resultante é
X
. O mesmo se aplica a:
CONCAT()
, GREATEST()
,
IF()
, LEAST()
,
CASE
, UNION
,
||
, ELT()
.
Para operações que convertem para dados de caracteres, o
resultado do conjunto de caracteres e collation da string estão
no connection/literals character set e
possuem a connection/literals collation.
Isto se aplica a: CHAR()
,
CAST()
, CONV()
,
FORMAT()
. HEX()
,
SPACE()
.
CONVERT()
fornece um modo de converter dados
entre diferentes conjunto de caracteres. A sintaxe é:
CONVERT(expr USING transcoding_name)
No MySQL, nomes transcodificados são o mesmo que o nomes dos conjuntos de caracteres correspondentes.
Exemplos:
SELECT CONVERT(_latin1'Müller' USING utf8); INSERT INTO utf8table (utf8column) SELECT CONVERT(latin1field USING utf8) FROM latin1table;
CONVERT(... USING ...)
é implementado de
acordo com a especificação SQL-99.
Você também pode usar CAST()
para converter
uma string para um conjunto de caracteres diferente. O novo
formato é:
CAST ( character_string AS character_data_type CHARACTER SET character_set_name )
Exemplo:
SELECT CAST(_latin1'test' AS CHAR CHARACTER SET utf8);
Você não usar uma cláusula COLLATE
dentro
de um CAST()
, mas você pode usá-la fora,
isto é, CAST(... COLLATE ...)
é ilegal mas
CAST(...) COLLATE ...
é permitido.
Exemplo:
SELECT CAST(_latin1'test' AS CHAR CHARACTER SET utf8) COLLATE utf8_bin;
Se você usar CAST()
sem especificar
CHARACTER SET
, então o conjunto de
caracteres e collation resultante são o conjunto de caracteres
da conexão/literal e a sua collation padrão. Se você usar
CAST()
com CHARACTER SET
X
, então o conjunto de caracteres resultante é
X
e a collation resultante é a collation
padrão de X
.
O comando SHOW CHARACTER SET
exibe todos os
conjunto de caracteres dsiponíveis. Ele aceita uma cláusula
LIKE
opcional que indica qual nome de
conjunto de caracteres coincidir.
Por exemplo:
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 |
+---------+-----------------------------+-------------------+--------+
4 rows in set (0.00 sec)
Notas sobre a lista precedente:
A coluna Maxlen
exie o número máximo de
bytes usado para armazenar um caracter.
A saída de SHOW COLLATION
inclui todos os
conjunto de caracteres disponíveis. Ele tem uma cláusula
LIKE
opcional que indice com qual nome de
collation que ele deve coincidir.
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 |
+-------------------+---------+----+---------+----------+---------+
7 rows in set (0.00 sec)
A coluna Default
indica se uma collation é o
padrão para o seu conjunto de caracteres.
Compiled
indica se o conjunto de caracteres
é ou não compilado no servidor. Sortlen
é
relacionado a quantidade de memória exigida para armazenar
strings expressadas no conjunto de caracteres.
A consulta seguinte mostra uma instrução CREATE
DATABASE
que criará o banco de dados dado. O
resultado inclui todas as opções de banco de dados.
DEFAULT CHARACTER SET
e
COLLATE
são suportados. Todas as opções de
banco de dados são armazenadas em um arquivo texto que pode se
encontrado no diretório de banco de dados.
mysql> SHOW CREATE DATABASE a;
+----------+---------------------------------------------------------------------------------+
| Database | Create Database |
+----------+---------------------------------------------------------------------------------+
| a | CREATE DATABASE `a` /*!40100 DEFAULT CHARACTER SET macce COLLATE macce_ci_ai */ |
+----------+---------------------------------------------------------------------------------+
1 row in set (0.00 sec)
A instrução SHOW COLUMNS
agora mostra as
collations das colunas da tabela, quando chamado como
SHOW FULL COLUMNS
. Colunas com tipos de dados
CHAR
, VARCHAR
ou
TEXT
tem collation
não-NULL
. Tipos numéricos e outros que não
seja caracteres tem collations NULL
. Por
exemplo:
mysql> SHOW FULL COLUMNS FROM a;
+-------+---------+-------------------+------+-----+---------+-------+
| Field | Type | Collation | Null | Key | Default | Extra |
+-------+---------+-------------------+------+-----+---------+-------+
| a | char(1) | latin1_swedish_ci | YES | | NULL | |
| b | int(11) | NULL | YES | | NULL | |
+-------+---------+-------------------+------+-----+---------+-------+
2 rows in set (0.02 sec)
O conjunto de caracteres não é parte do display.
Existem dois novos conjunto de caracteres para armazenar dados
Unicode: ucs2
(o conjunto de caracteres UCS-2
Unicode) e utf8
(a codificação UTF-8 do
conjunto de caracteres do Unicode).
Na UCS-2 (representação Unicode binária) todo caracter é representado por um código Unicode de dois bytes com o byte mais significante primeiro. Por exemplo: "LATIN CAPITAL LETTER A" tem o código 0x0041 e é armazenado como uma sequência de dois bytes: 0x00 0x41. "CYRILLIC SMALL LETTER YERU" (Unicode 0x044B) é armazenada como uma sequência de dois bytes: 0x04 0x4B. Para caracteres Unicode e seus código veja a Unicode Home Page.
Restrição temporária: UCS-2 não pode (ainda) ser usado
como um conjunto de caracteres de cliente. Insto significa que
SET NAMES ucs2
não funcionará.
O conjunto de caracteres UTF8 (representação Unicode trasnformada) é um modo alternativo de armazenar dados Unicode. Ele é implementado de acordo com a RFC2279. A idéia do conjunto de caracteres UTF8 é que vários caracteres Unicodes cobem em uma sequência de bytes de tamanhos diferentes.
Letras, digitos e sinais de pontuação do Latin básico usam um byte.
A maioria das letras script da Europa e Oriente Médio cabem em uma sequência de dois bytes: letras Latin extendidas (com til, agudo, grave e outros acentos), Cirílico, Grego, Armenio, Hebreu, Árabe, Sírio e outors.
Ideógrafos Coreanos, Chineses e Japoneses usam sequências de três bytes.
Atualmente, o suporte MySQL UTF8 não inclui sequências de quatro-bytes.
Dica: economize spaço com UTF8, use
VARCHAR
em vez de CHAR
.
Senão, o MySQL tem que reservar 30 bytes para uma coluna
CHAR(10) CHARACTER SET utf8
, pois este é o
tamanho máximo possível.
O metadados é o dado sobre o dado. Qualquer coisa que descreva os
bancos de dados, como o opsto de ser o conteúdo do banco de
dados, é metadados. Assim nomes de colunas, banco de dados,
usuários, versões e a maioria dos resultados strings de
SHOW
, são metadados.
Todos os metadados devem estar no mesmo conjunto de caracteres.
(Senão, SHOW
não funcionaria corretamente
devido aos diferentes registros na mesma coluna estarem em
conjunto de caracteres diferentes). Por outro lado, metadados
devem incluir todos os caracteres em todas as linguagens (senào
os usuários não poderiam nomear as colunas e tabelas na suas
próprias linguagens). Para permitir ambos os objetivos, o MySQL
armazena metadados em um conjunto de caracteres Unicode, chamado
UTF8. Isto não causa qualquer rompimento se você nunca usar
caracteres acentuados. Mas se você fizer, deverá estar ciente
que o metadado está em UTF8.
Isto significa que funções USER()
(e seus
sinônimos), SESSION_USER()
and
SYSTEM_USER()
),
CURRENT_USER()
, e VERSION()
terá o conjunto de caracteres UTF8 por padrão.
Isto NÃO significa que o cabeçalho das colunas e os resultados
da função DESCRIBE
estarão no conjunto de
caracteres UTF8 por padrão. (Quando você fizer SELECT
column1 FROM t
o nome column1
será
retornado do servidor para o cliente no conjunto de caracteres do
cliente como determinado pela instrução SET
NAMES
.)
Se você quizer que o servidor passe o resultado de volta em um
conjunto de caracteres não-UTF8, então use SET
CHARACTER SET
para forçar o servidor a converter (see
Secção 9.3.6, “Conjunto de Caracteres e Collation de Conexão”), ou configurar o cliente
para fazer a a conversão, mas esta opção não estará
disponível para muitos clientes até no final no ciclo do produto
MySQL 4.x.
Se você está apenas usando, por exemplo, a função
USER()
para comparação ou atribuição dentro
de uma única instrução ... não preocupe. O MySQL fará alguma
conversão automática para você.
SELECT * FROM Table1 WHERE USER() = latin1_column;
Isto funcionará, porque o conteúdo de
latin1_column
é convertido automaticamente
para UTF8 antes da comparação.
INSERT INTO Table1 (latin1_column) SELECT USER();
Isto funcionará, porque o contéudo de USER()
é convertido automaticamente para latin1
antes
da atribuição. A conversão automática ainda não está
totalmente implementada, mas deve funcionar corretamente em uma
versão posterior.
Embora a conversão automática não esteja no padrão SQL, o documento do padrão SQL diz que todo conjunto de caracteres é (em termos de caracteres suportados) um ``subconjunto'' do Unicode. Desde que isto seja um princípio bem conhecido que ``o que aplica a um superconjunto pode ser aplicado a um subconjunto'', acreditamos que uma collation para Unicode pode ser aplicado para comparações com strings não -Unicode.
NATA DA VERSÃO 4.1.1: Os arquivos errmsg.txt
estarão todos em UTF8 depois deste ponto. Conversão o conjunto
de caracteres do clientes serão automáticos, como para
metadados. Também: Podemos alterar o comportamento padrão para
passar de volta o metadado do resultado em um futuro próximo.
Para compatibilidade com o SAP DB estas duas instruções são a mesma:
CREATE TABLE t1 (f1 CHAR(n) UNICODE); CREATE TABLE t1 (f1 CHAR(n) CHARACTER SET ucs2);
No MySQL 4.1, a configuração de um conjunto de caracteres é
armazenado em um arquivo XML, um arquivo por conjunto de
caracteres (na versão anterior, esta informação era armazenada
em arquivos .conf
)
No MySQL-4.x e mais novos, NCHAR
e
CHAR
eram sinônimos. ANSI define
NCHAR
ou NATIONAL CHAR
como
um modo de definir que uma coluna CHAR
deve
usar alguns conjuntos de caracteres predefinidos. O MySQL usa
utf8
como o conjunto de caracteres predefinido.
Por exemplo, estas declarações de tipos de colunas são
equivalentes:
CHAR(10) CHARACTER SET utf8 NATIONAL CHARACTER(10) NCHAR(10)
Como estas:
VARCHAR(10) CHARACTER SET utf8 NATIONAL VARCHAR(10) NCHAR VARCHAR(10) NATIONAL CHARACTER VARYING(10) NATIONAL CHAR VARYING(10)
Você pode usar N'literal'
para criar uma
string em um conjunto de caracteres nacional.
Estas duas instruções são equivaletes:
SELECT N'some text'; SELECT _utf8'some text';
Agora, e sobre a atalização de versões mais antigas do MySQL? o MySQL 4.1 é quase compaível com o MySQL 4.0 e versões anteriores pela simples razão que quase todos os recursos são novos, então não há nada em versões anteriores que conflitem com ele. No entanto, existem algumas diferenças e poucas coisas com as quais deve estar ciente.
O mais importante: O ``conjunto de caracteres do MySQL 4.0'' tem as propriedades do ``conjunto de caracteres do MySQL 4.1'' e da ``collation do MySQL 4.1''. Você terá que desaprender isto. qui pra frente não iremos empacotar o conjunto de caracteres e a collation no mesmo objeto.
Existe um tratamento especial do conjunto de caracteres nacional
no MySQL 4.1. NCHAR
não é o mesmo que
CHAR
e literais N'...'
não
são o mesmo dos literais '...'
.
Finalmente, existe um formato de arquivo diferente para armazenar
informações sobre conjunto de caracteres e collation. Esteja
certo que você reinstalou o diretório
/share/mysql/charsets/
contendo o novo
arquivo de configurações.
Se você quiser iniciar o mysqld
de uma
distribuição 4.1.x com dados craidos pelo MySQL 4.0, você deve
iniciar o servidor com o mesmo conjunto de caracteres e collation.
Neste caso você não precisará de reindexar os dados.
Existem dois modos de fazê-lo:
shell>./configure --with-character-set=... --with-collation=...
shell>./mysqld --default-character-set=... --default-collation=...
Se você usou o mysql
com, por exemplo,
oconjunto de caracteres danish
do MySQL 4.0,
você agora deve usar o conjunto de caracteres
latin1
e a collation
latin1_danish_ci
:
shell>./configure --with-character-set=latin1
--with-collation=latin1_danish_ci shell>./mysqld --default-character-set=latin1
--default-collation=latin1_danish_ci
Use a tabela mostrada na próxima seção para encontrar o nome do antigo conjunto de caracteres do MySQL 4.0 e o par conjunto de caracteres/collation equivalente no MySQL 4.1.
ID | Conjunto de Caracter - 4.0 | Conjunto de Caracter - 4.1 | Collation - 4.1 |
1 | big5 | big5 | big5_chinese_ci |
2 | czech | latin2 | latin2_czech_ci |
3 | dec8 | dec8 | dec8_swedish_ci |
4 | dos | cp850 | cp850_general_ci |
5 | german1 | latin1 | latin1_german1_ci |
6 | hp8 | hp8 | hp8_english_ci |
7 | koi8_ru | koi8r | koi8r_general_ci |
8 | latin1 | latin1 | latin1_swedish_ci |
9 | latin2 | latin2 | latin2_general_ci |
10 | swe7 | swe7 | swe7_swedish_ci |
11 | usa7 | ascii | ascii_general_ci |
12 | ujis | ujis | ujis_japanese_ci |
13 | sjis | sjis | sjis_japanese_ci |
14 | cp1251 | cp1251 | cp1251_bulgarian_ci |
15 | danish | latin1 | latin1_danish_ci |
16 | hebrew | hebrew | hebrew_general_ci |
17 | win1251 | (removed) | (removed) |
18 | tis620 | tis620 | tis620_thai_ci |
19 | euc_kr | euckr | euckr_korean_ci |
20 | estonia | latin7 | latin7_estonian_ci |
21 | hungarian | latin2 | latin2_hungarian_ci |
22 | koi8_ukr | koi8u | koi8u_ukrainian_ci |
23 | win1251ukr | cp1251 | cp1251_ukrainian_ci |
24 | gb2312 | gb2312 | gb2312_chinese_ci |
25 | greek | greek | greek_general_ci |
26 | win1250 | cp1250 | cp1250_general_ci |
27 | croat | latin2 | latin2_croatian_ci |
28 | gbk | gbk | gbk_chinese_ci |
29 | cp1257 | cp1257 | cp1257_lithuanian_ci |
30 | latin5 | latin5 | latin5_turkish_ci |
31 | latin1_de | latin1 | latin1_german2_ci |
Aqui está uma lista do conjunto de caracter e collation que o MySQL suporta. Como as opções e configuração de instalação diferem, alguns sites não terão todos os itens da lista, e alguns sites terão itens que não estão na lista porque a definição de novos conjunto de caracteres e collation é direto.
O MySQL suporta mais de 70 collations e mais de 30 conjunto de caracteres.
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 |
| cp1251 | Windows Cyrillic | cp1251_bulgarian_ci | 1 |
| 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 |
| cp1256 | Windows Arabic | cp1256_general_ci | 1 |
| cp1257 | Windows Baltic | cp1257_general_ci | 1 |
| binary | Binary pseudo charset | binary | 1 |
+----------+-----------------------------+---------------------+--------+
33 rows in set (0.01 sec)
NB: TODOS OS CONJUNTO DE CARACTERES TEM UMA COLLATION BINÁRIA. NÃO INCLUÍMOS A COLLATION BINÁRIA EM TODAS AS DESCRIÇÕES A SEGUIR.
É claro que existem os nossos dois conjuntos de caracteres Unicode. Você pode armazenar texto em cerca de 650 línguas usando estes conjunto de caracteres. Não adicionamos um grande número de collations para estes dois novos conjuntos ainda, mas isto acontecerá logo. Agora eles possuem a collation caso-insensitivo e acento-insensitivo, mais a collation binária.
+---------+-----------------+-------------------+--------+ | Charset | Description | Default collation | Maxlen | +---------+-----------------+-------------------+--------+ | utf8 | UTF-8 Unicode | utf8_general_ci | 3 | | ucs2 | UCS-2 Unicode | ucs2_general_ci | 2 | +---------+-----------------+-------------------+--------+
+----------+-----------------------------+---------------------+--------+ | Charset | Description | Default collation | Maxlen | +----------+-----------------------------+---------------------+--------+ | dec8 | DEC West European | dec8_swedish_ci | 1 | | hp8 | HP West European | hp8_english_ci | 1 | +----------+-----------------------------+---------------------+--------+
+----------+-----------------------------+---------------------+--------+ | Charset | Description | Default collation | Maxlen | +----------+-----------------------------+---------------------+--------+ | armscii8 | ARMSCII-8 Armenian | armscii8_general_ci | 1 | | cp1256 | Windows Arabic | cp1256_general_ci | 1 | | hebrew | ISO 8859-8 Hebrew | hebrew_general_ci | 1 | | greek | ISO 8859-7 Greek | greek_general_ci | 1 | | latin5 | ISO 8859-9 Turkish | latin5_turkish_ci | 1 | | geostd8 | Georgian | geostd8_general_ci | 1 | +----------+-----------------------------+---------------------+--------+
O conjunto de caracteres Asiático que suportamos inclui Chinês, Japonês, Coreano e Tailandês. Estes podem ser complicados. Por exemplo, o conjunto Chinês devem permitir milhares de caracteres diferentes.
+----------+-----------------------------+---------------------+--------+ | Charset | Description | Default collation | Maxlen | +----------+-----------------------------+---------------------+--------+ | big5 | Big5 Traditional Chinese | big5_chinese_ci | 2 | | gb2312 | GB2312 Simplified Chinese | gb2312_chinese_ci | 2 | | gbk | GBK Simplified Chinese | gbk_chinese_ci | 2 | | euckr | EUC-KR Korean | euckr_korean_ci | 2 | | ujis | EUC-JP Japanese | ujis_japanese_ci | 3 | | sjis | Shift-JIS Japanese | sjis_japanese_ci | 2 | | tis620 | TIS620 Thai | tis620_thai_ci | 1 | +----------+-----------------------------+---------------------+--------+
O conjunto de caracter Báltico cobre as linguagens da Estonia, Letônia e Lituânia. Existem dois conjunto de caracteres Bálticos suportados:
latin7
(ISO 8859-13 Baltic):
+----------------------+----------+----+---------+----------+---------+ | Collation | Charset | Id | Default | Compiled | Sortlen | +----------------------+----------+----+---------+----------+---------+ | latin7_estonian_cs | latin7 | 20 | | | 0 | | latin7_general_ci | latin7 | 41 | Yes | | 0 | | latin7_general_cs | latin7 | 42 | | | 0 | | latin7_bin | latin7 | 79 | | | 0 | +----------------------+----------+----+---------+----------+---------+
cp1257
(Windows Baltic):
+----------------------+----------+----+---------+----------+---------+ | Collation | Charset | Id | Default | Compiled | Sortlen | +----------------------+----------+----+---------+----------+---------+ | cp1257_lithuanian_ci | cp1257 | 29 | | | 0 | | cp1257_bin | cp1257 | 58 | | | 0 | | cp1257_general_ci | cp1257 | 59 | Yes | | 0 | +----------------------+----------+----+---------+----------+---------+
Aqui estão os conjunto de caracteres e collation cirílicos para uso com as linguagens Belarússia, Búlgaro, Russo e Ucraniano.
cp1251
(Windows Cyrillic):
+----------------------+----------+----+---------+----------+---------+ | Collation | Charset | Id | Default | Compiled | Sortlen | +----------------------+----------+----+---------+----------+---------+ | cp1251_bulgarian_ci | cp1251 | 14 | | | 0 | | cp1251_ukrainian_ci | cp1251 | 23 | | | 0 | | cp1251_bin | cp1251 | 50 | | | 0 | | cp1251_general_ci | cp1251 | 51 | Yes | | 0 | | cp1251_general_cs | cp1251 | 52 | | | 0 | +----------------------+----------+----+---------+----------+---------+
cp866
(DOS Russian):
+----------------------+----------+----+---------+----------+---------+ | Collation | Charset | Id | Default | Compiled | Sortlen | +----------------------+----------+----+---------+----------+---------+ | cp866_general_ci | cp866 | 36 | Yes | | 0 | | cp866_bin | cp866 | 68 | | | 0 | +----------------------+----------+----+---------+----------+---------+
koi8r
(KOI8-R Relcom Russian, primarily
used in Russia on Unix):
+----------------------+----------+----+---------+----------+---------+ | Collation | Charset | Id | Default | Compiled | Sortlen | +----------------------+----------+----+---------+----------+---------+ | koi8r_general_ci | koi8r | 7 | Yes | | 0 | | koi8r_bin | koi8r | 74 | | | 0 | +----------------------+----------+----+---------+----------+---------+
koi8u
(KOI8-U Ukrainian, primarily used
in Ukraine on Unix):
+----------------------+----------+----+---------+----------+---------+ | Collation | Charset | Id | Default | Compiled | Sortlen | +----------------------+----------+----+---------+----------+---------+ | koi8u_general_ci | koi8u | 22 | Yes | | 0 | | koi8u_bin | koi8u | 75 | | | 0 | +----------------------+----------+----+---------+----------+---------+
Temos algum suporte para conjunto de caracteres usados na República Tcheca, Eslováquia, Hungria, Romênia, Eslovênia, Croácia e Polônia.
cp1250
(Windows Central European):
+----------------------+----------+----+---------+----------+---------+ | Collation | Charset | Id | Default | Compiled | Sortlen | +----------------------+----------+----+---------+----------+---------+ | cp1250_general_ci | cp1250 | 26 | Yes | | 0 | | cp1250_czech_ci | cp1250 | 34 | | Yes | 2 | | cp1250_bin | cp1250 | 66 | | | 0 | +----------------------+----------+----+---------+----------+---------+
cp852
(DOS Central European):
+----------------------+----------+----+---------+----------+---------+ | Collation | Charset | Id | Default | Compiled | Sortlen | +----------------------+----------+----+---------+----------+---------+ | cp852_general_ci | cp852 | 40 | Yes | | 0 | | cp852_bin | cp852 | 81 | | | 0 | +----------------------+----------+----+---------+----------+---------+
macce
(Mac Central European):
+----------------------+----------+----+---------+----------+---------+ | Collation | Charset | Id | Default | Compiled | Sortlen | +----------------------+----------+----+---------+----------+---------+ | macce_general_ci | macce | 38 | Yes | | 0 | | macce_bin | macce | 43 | | | 0 | +----------------------+----------+----+---------+----------+---------+
latin2
(ISO 8859-2 Central European):
+----------------------+----------+----+---------+----------+---------+ | Collation | Charset | Id | Default | Compiled | Sortlen | +----------------------+----------+----+---------+----------+---------+ | latin2_czech_ci | latin2 | 2 | | Yes | 4 | | latin2_general_ci | latin2 | 9 | Yes | | 0 | | latin2_hungarian_ci | latin2 | 21 | | | 0 | | latin2_croatian_ci | latin2 | 27 | | | 0 | | latin2_bin | latin2 | 77 | | | 0 | +----------------------+----------+----+---------+----------+---------+
keybcs2
(DOS Kamenicky Czech-Slovak):
+----------------------+----------+----+---------+----------+---------+ | Collation | Charset | Id | Default | Compiled | Sortlen | +----------------------+----------+----+---------+----------+---------+ | keybcs2_general_ci | keybcs2 | 37 | Yes | | 0 | | keybcs2_bin | keybcs2 | 73 | | | 0 | +----------------------+----------+----+---------+----------+---------+
O Cojunto de Caracteres da Europa Ocidental cobre a maioria das linguagens desta região como Francês, Espanhol, Catalão, Basco, Português, Italiano, Albanês, Holandês, Alemão, Finlandes, Dinamarquês, Sueco, Norueguês, Faroese, Islandês, Irlandês, Escocês e Inglês
latin1
(ISO 8859-1 West European):
+----------------------+----------+----+---------+----------+---------+ | 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 | +----------------------+----------+----+---------+----------+---------+
A collation latin1_swedish_ci
é o
padrão que provavelmente é usado pela maioria dos
usuários do MySQL. É constantemente indicado que ele é
baseado nas regras de collation do Suéco/Finlandês, mas
você encontrará Suécos e Finlandeses que descordam desta
afirmação.
As collations latin1_german1_ci
e
latin1_german2_ci
são baseadas nos
padrões DIN-1 e DIN-2, onde DIN significa Deutsches
Institut für Normung (isto é, a resposta Alemã ao ANSI).
DIN-1 é chamada collation de dicionário e o DIN-2 é
chamado a collation de agenda.
Regras latin1_german1_ci
(dicionários):
‘Ä
’ = ‘A
’, ‘Ö
’ = ‘O
’, ‘Ü
’ = ‘U
’, ‘ß
’ = ‘s
’
Regras latin1_german2_ci
(agendas):
‘Ä
’ = 'AE
', ‘Ö
’ = 'OE
', ‘Ü
’ = 'UE
', ‘ß
’ = 'ss
'
macroman
(Mac West European):
+----------------------+----------+----+---------+----------+---------+ | Collation | Charset | Id | Default | Compiled | Sortlen | +----------------------+----------+----+---------+----------+---------+ | macroman_general_ci | macroman | 39 | Yes | | 0 | | macroman_bin | macroman | 53 | | | 0 | +----------------------+----------+----+---------+----------+---------+
cp850
(DOS West European):
+----------------------+----------+----+---------+----------+---------+ | Collation | Charset | Id | Default | Compiled | Sortlen | +----------------------+----------+----+---------+----------+---------+ | cp850_general_ci | cp850 | 4 | Yes | | 0 | | cp850_bin | cp850 | 80 | | | 0 | +----------------------+----------+----+---------+----------+---------+
This is a translation of the MySQL Reference Manual that can be found at dev.mysql.com. The original Reference Manual is in English, and this translation is not necessarily as up to date as the English version.