{"id":10,"date":"2008-12-08T08:44:24","date_gmt":"2008-12-08T06:44:24","guid":{"rendered":"http:\/\/code.openark.org\/blog\/?p=10"},"modified":"2008-12-16T09:58:14","modified_gmt":"2008-12-16T07:58:14","slug":"mysqls-character-sets-and-collations-demystified","status":"publish","type":"post","link":"https:\/\/code.openark.org\/blog\/mysql\/mysqls-character-sets-and-collations-demystified","title":{"rendered":"MySQL’s character sets and collations demystified"},"content":{"rendered":"

MySQL’s character sets and collations are often considered as a mystery, and many users either completely disregard them and keep with the defaults, or set everything to UTF8.<\/p>\n

This post will attempt to shed some light on the mystery, and provide with some best practices for use with text columns with regard to character sets.<\/p>\n

Character Sets<\/h4>\n

A thorough discussion of how the character sets have evolved through history is beyond the scope of this post. While the Unicode standard is gaining recognition, the “older” character sets are still around. Understanding the difference between Unicode and local character sets is crucial.<\/p>\n

Consider, for example, MySQL’s latin1<\/code><\/strong> character set. In this character set there are 256 different characters, represented by one byte. The first 128 characters map to ASCII, the standard “ABCabc012 dot comma” set, of which most of this post is composed. The latter 128 characters in latin1<\/code><\/strong> are composed of West European specific characters, such as \u00c0, \u00eb, \u00f5, \u00d1.<\/p>\n

A Name VARCHAR(60) CHARSET latin1<\/code><\/strong> column can describe names with West European characters. But it cannot describe Russian or Hebrew names. To represent a name in Hebrew, you’d need the hebrew<\/code><\/strong> charset (ISO 8859-8), in which the first 128 characters are, as always, mapped to ASCII, and the latter 128 characters describe the Hebrew alphabet and punctuation marks, such as \u05e9,\u05dc,\u05de,\u05d4. The Cyrillic, Arabic and Turkish charsets follow in a similar manner.<\/p>\n

Assume now I’m building a world wide web application, such as a popular social network. I would like to store the first names of my users, in every possible language. None of the above character sets support all languages. I therefore turn to Unicode<\/a>. In particular, MySQL supports utf8<\/code><\/strong>, a Unicode encoding scheme, which is commonly used due to its economic storage requirements.<\/p>\n

In Unicode there is a dedicated number for each letter in the known languages, in ancient languages, and some imaginary or otherwise non existing languages, such as Klingon (yes, I know there are people who actually speak Klingon), may yet find their way into the standard.<\/p>\n

UTF8 (or utf8), a Unicode encoding scheme, states the following: for ASCII characters, such as ‘a’, ‘6’, ‘$’, only one byte of storage is required. For Hebrew, Cyrillic or Turkish characters, 2 bytes are required. For Japanese, Chinese – more (MySQL supports up to 3 bytes per character). Again, the exact details of the implementation are beyond the scope of this post, and are well described here<\/a> and here.<\/a><\/p>\n

What’s important to me is that I can define Name VARCHAR(30) CHARSET utf8<\/code><\/strong> for my columns, and Voila! Any name can be represented in my database.<\/p>\n

So why not define everything as utf8 and get done with it?<\/h4>\n

Well, it just so happens that Unicode comes with a price. See, for example, the following column definition:<\/strong><\/p>\n

CountryCode CHAR(3) CHARSET utf8<\/code><\/p><\/blockquote>\n

We are asking for a column with 3 characters exactly. The required storage for this column will be such that any 3-letter name must fit in. This means (3 characters) times (3 bytes per character) = 9 bytes of storage. So CHAR<\/code><\/strong> and utf8<\/code><\/strong> together may be less than ideal. VARCHAR<\/code><\/strong> behaves better: it only requires as many bytes per character as described above. So the text “abc” will only require 3 bytes (plus VARCHAR<\/code><\/strong>‘s leading 1 or 2 bytes).<\/p>\n

Why don’t we drop the ‘CHAR’ altogether, then, and use only ‘VARCHAR’?<\/h4>\n

Because some values are simply better represented with CHAR<\/code><\/strong>: consider a “password” column, encoded with MD5. The MD5()<\/code><\/strong> function returns a 32 characters long text. It’s always 32 characters, and, moreover, it’s always in ASCII. The best data type and character set definition would be password CHAR(32) CHARSET ascii<\/code><\/strong>. We thus ensure exactly 32 bytes are allocated to this column. A VARCHAR<\/code><\/strong> will acquire an additional byte or two, depending on its defined length, which will indicate the length of the text.<\/p>\n

And why would I care about collations?<\/h4>\n

Collations deal with text comparison. We observed that the default character set in MySQL is latin1<\/code><\/strong>. The default collation is latin1_swedish_ci<\/code><\/strong>. In this collation the following holds true: 'ABC' = 'abc'<\/code><\/strong>.<\/p>\n

Wait. What?<\/p>\n

Look at the “ci” in latin1_swedish_ci<\/code><\/strong>. It stands for “case insensitive”. Collations which end with “cs” or “bin” are case sensitive. The utf8<\/code><\/strong> character set comes with utf8_general_ci<\/code><\/strong> collation. This can make sense. Let’s review our web application table (I’m using plain text passwords here, bare with me for this example):<\/p>\n

\n
CREATE TABLE my_users (\r\n  name VARCHAR(30) CHARSET utf8 COLLATE utf8_general_ci,\r\n  plainPassword VARCHAR(16) CHARSET ASCII,\r\n  UNIQUE KEY (name)\r\n);\r\nINSERT INTO my_users (name, password) VALUES ('David', 'mypass');<\/pre>\n<\/blockquote>\n
It holds true that the name ‘David’ equals ‘david’. If I were to SELECT * FROM my_users WHERE name='david'<\/code><\/strong>, I would find the desired row. The unique key will also guarantee that no daVID user can be added.<\/p>\n
But David certainly wouldn’t want users to login with the password ‘MYPASS’. So we refine our table:<\/p>\n
\n
CREATE TABLE my_users (\r\n  name VARCHAR(30) CHARSET utf8 COLLATE utf8_general_ci,\r\n  plainPassword VARCHAR(16) CHARSET ascii COLLATE ascii_bin,\r\n  UNIQUE KEY (name)\r\n);<\/pre>\n<\/blockquote>\n
The ascii_bin<\/code><\/strong> collation is a case sensitive collation for ascii<\/code><\/strong>. The following will not find anything:<\/p>\n
SELECT * FROM my_users WHERE name='david' AND plainPassword='MYPASS';<\/code><\/p><\/blockquote>\n
Holding a plain text password in your database is not a best practice, but apparently it’s common.<\/p>\n
Collations also deal with text ordering. For any two strings, the collation determines which is larger, or if they are equal. Probably the most common situation you see collations in action is when you ORDER BY<\/strong> a text column.<\/p>\n
Also keep in mind<\/h4>\n