Kapitel 10. Zeichensatz-Unterstützung
Zurück |  | Weiter

## Kapitel 10. Zeichensatz-Unterstützung

MySQL enthält eine Zeichensatzunterstützung, mit deren Hilfe Sie Daten mit einer Vielzahl von Zeichensätzen speichern und Vergleiche auf der Basis einer Vielzahl von Sortierfolgen durchführen können. Sie können Zeichensätze auf der Server-, der Datenbank-, der Tabellen- und der Spaltenebene angeben. MySQL unterstützt die Verwendung von Zeichensätzen für die Speicher-Engines `MyISAM`, `MEMORY`, `NDBCluster` und `InnoDB`.

Dieses Kapitel behandelt die folgenden Themen:

- Was sind Zeichensätze und Sortierfolgen?

- Standardzeichensatzsystem auf mehreren Ebenen

- Syntax zur Angabe von Zeichensätzen und Sortierfolgen

- Betroffene Funktionen und Operationen

- Unicode-Unterstützung

- Verfügbare Zeichensätze und Sortierfolgen einschließlich entsprechender Anmerkungen

Zeichensatzbezogene Aspekte wirken sich auf die Datenspeicherung, aber auch auf die Kommunikation zwischen Clientprogrammen und dem MySQL Server aus. Wenn Sie wollen, dass das Clientprogramm mit dem Server unter Verwendung eines Zeichensatzes kommuniziert, der sich vom Standardzeichensatz unterscheidet, dann müssen Sie angeben, welcher Zeichensatz verwendet werden soll. Um beispielsweise den `utf8`-Unicode-Zeichensatz zu verwenden, setzen Sie nach der Herstellung einer Serververbindung folgende Anweisung ab:

    SET NAMES 'utf8';

Weitere Informationen zu zeichensatzbezogenen Fragen in der Client/Server-Kommunikation finden Sie in Abschnitt 10.4, „Verbindungszeichensatz und -sortierfolge“.

## 10.1. Zeichensätze und Sortierfolgen im Allgemeinen

Ein Zeichensatz ist eine Menge mit Symbolen und Kodierungen. Eine Sortierfolge ist ein Regelsatz für den Vergleich von Zeichen in einem Zeichensatz. Folgendes Beispiel, welches einen imaginären Zeichensatz verwendet, soll den Unterschied verdeutlichen.

Angenommen, wir haben ein Alphabet mit vier Buchstaben: ‘`A`’, ‘`B`’, ‘`a`’, ‘`b`’. Jedem Buchstaben weisen wir nun eine Zahl zu: ‘`A`’ = 0, ‘`B`’ = 1, ‘`a`’ = 2, ‘`b`’ = 3. Der Buchstabe ‘`A`’ ist ein Symbol, die Zahl 0 die Kodierung für ‘`A`’. Die Kombination aller vier Buchstaben und ihrer Kodierungen bildet den Zeichensatz.

Angenommen, wir wollen zwei String-Werte ‘`A`’ und ‘`B`’ miteinander vergleichen. Die einfachste Möglichkeit, dies zu tun, besteht in einem Blick auf die Kodierungen: 0 für ‘`A`’ und 1 für ‘`B`’. Da 0 kleiner als 1 ist, sagen wir, dass ‘`A`’ kleiner als ‘`B`’ ist. Was wir gerade getan haben, war die Anwendung einer Sortierfolge für unseren Zeichensatz. Die Sortierfolge ist eine Menge von Regeln – wenn auch in diesem Fall nur eine Regel: „Vergleiche die Kodierungen“. Diese einfachste aller möglichen Sortierfolgen nennen wir Binärsortierung.

Was aber, wenn wir ausdrücken wollen, dass Klein- und Großbuchstaben äquivalent sind? Dann hätten wir schon zwei Regeln: (1) Betrachte die Kleinbuchstaben ‘`a`’ und ‘`b`’ als äquivalent zu den entsprechenden Großbuchstaben ‘`A`’ und ‘`B`’. (2) Vergleiche die Kodierungen. Dies ist eine Sortierfolge ohne Unterscheidung der Groß-/Kleinschreibung. Sie ist ein kleines bisschen komplexer als eine Binärsortierung.

Im wirklichen Leben umfassen die meisten Zeichensätze viele Zeichen: nicht nur ‘`A`’ und ‘`B`’, sondern ganze Alphabete – manchmal sogar mehrere Alphabete oder fernöstliche Schreibsysteme mit Tausenden von Zeichen – sowie viele Sonder- und Interpunktionszeichen. Auch für Sortierfolgen gibt es im wirklichen Leben viele Regeln, die nicht nur die Behandlung der Groß-/Kleinschreibung angeben, sondern auch, ob Akzente und Tremata (die Punkte etwa auf den deutschen Umlauten Ä, Ö und Ü) unterschieden und wie Folgen aus mehreren Zeichen zugeordnet werden (beispielsweise die Regel, dass bei einer der beiden deutschen Sortierfolgen die Gleichung ‘`Ö`’ = ‘`OE`’ gilt).

MySQL erlaubt Ihnen

- das Speichern von Strings in einer Vielzahl von Zeichensätzen,

- das Vergleichen von Strings unter Verwendung einer Vielzahl von Sortierfolgen,

- das Mischen von Strings verschiedener Zeichensätze oder Sortierfolgen auf demselben Server, in derselben Datenbank oder sogar derselben Tabelle,

- die Angabe von Zeichensatz und Sortierfolge auf beliebiger Ebene.

In dieser Hinsicht ist MySQL den meisten anderen Datenbanksystemen weit überlegen. Allerdings müssen Sie, um diese Funktionen effizient nutzen zu können, wissen, welche Zeichensätze und Sortierfolgen verfügbar sind, wie Sie die Standardeinstellungen ändern und wie diese das Verhalten von String-Operatoren und -Funktionen beeinflussen.

## 10.2. Zeichensätze und Sortierfolgen in MySQL

Der MySQL Server kann viele Zeichensätze unterstützen. Um die verfügbaren Zeichensätze aufzulisten, verwenden Sie die Anweisung `SHOW CHARACTER SET`. Nachfolgend ist eine Teilausgabe abgebildet. Umfassendere Informationen finden Sie in Abschnitt 10.9, „Zeichensätze und Sortierfolgen, die MySQL unterstützt“.

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

Ein gegebener Zeichensatz hat stets mindestens eine Sortierfolge. Es können aber auch mehrere sein. Um die verfügbaren Sortierfolgen eines Zeichensatzes aufzulisten, verwenden Sie die Anweisung `SHOW COLLATION`. Um etwa die Sortierfolgen für den Zeichensatz `latin1` (cp1252, westeuropäisch) aufzulisten, suchen Sie mit der folgenden Anweisung die Sortierfolgennamen, die mit `latin1` beginnen:

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

Die `latin1`-Sortierfolgen haben die nachfolgend beschriebenen Bedeutungen:

Sortierfolge | Bedeutung
`latin1_german1_ci` | Deutsch, DIN-1
`latin1_swedish_ci` | Schwedisch/Finnisch
`latin1_danish_ci` | Dänisch/Norwegisch
`latin1_german2_ci` | Deutsch, DIN-2
`latin1_bin` | Binärsortierung nach `latin1`-Kodierung
`latin1_general_ci` | Mehrsprachig (westeuropäisch)
`latin1_general_cs` | Mehrsprachig (ISO, westeuropäisch), Unterscheidung der Groß-/Kleinschreibung
`latin1_spanish_ci` | Modernes Spanisch

Sortierfolgen haben die folgenden Eigenschaften:

- Zwei verschiedene Zeichensätze können nicht dieselbe Sortierfolge aufweisen.

- Jeder Zeichensatz hat genau eine Sortierfolge, die die Standardsortierfolge ist. So ist die Standardsortierfolge für `latin1` beispielsweise `latin1_swedish_ci`. Die Ausgabe von `SHOW CHARACTER SET` zeigt an, welche Sortierfolgen standardmäßig für die angezeigten Zeichensätze verwendet werden.

- Für Sortierfolgennamen gibt es eine Konvention: Sie beginnen mit dem Namen des Zeichensatzes, mit dem sie verknüpft sind, enthalten in der Regel den Namen der betreffenden Sprache und enden auf `_ci` (keine Unterscheidung der Groß-/Kleinschreibung), `_cs` (Unterscheidung der Groß-/Kleinschreibung) oder `_bin` (Binärsortierung).

## 10.3. Festlegen von Zeichensätzen und Sortierfolgen

Standardeinstellungen für Zeichensätze und Sortierfolgen gibt es auf vier Ebenen, nämlich der Server-, der Datenbank-, der Tabellen- und der Spaltenebene. Die folgende Beschreibung mag komplex erscheinen, es hat sich aber in der Praxis gezeigt, dass Standardeinstellungen auf mehreren Ebenen zu natürlichen und offensichtlichen Ergebnissen führen.

`CHARACTER SET` wird in Klauseln verwendet, die einen Zeichensatz angeben. `CHARSET` kann als Synonym von `CHARACTER SET` benutzt werden.

### 10.3.1. Serverzeichensatz und -sortierfolge

MySQL Server bietet einen Serverzeichensatz und eine Serversortierfolge. Diese können beim Serverstart eingestellt und zur Laufzeit geändert werden.

Anfangs hängen Zeichensatz und Sortierfolge des Servers von den Optionen ab, die Sie beim Start von mysqld verwenden. Sie können `--character-set-server` für den Zeichensatz benutzen. Daneben können Sie `--collation-server` hinzufügen, um die Sortierfolge anzugeben. Wenn Sie keinen Zeichensatz bestimmen, entspricht dies der Festlegung `--character-set-server=latin1`. Geben Sie nur einen Zeichensatz (z. B. `latin1`), aber keine Sortierfolge an, dann entspricht dies der Festlegung `--character-set-server=latin1` `--collation-server=latin1_swedish_ci`, weil `latin1_swedish_ci` die Standardsortierfolge für `latin1` ist. Aus diesem Grund haben die folgenden drei Befehle dieselben Auswirkungen:

    shell> mysqld
    shell> mysqld --character-set-server=latin1
    shell> mysqld --character-set-server=latin1 \
               --collation-server=latin1_swedish_ci

Eine Möglichkeit, die Einstellungen zu ändern, ist eine Neukompilierung. Wenn Sie die Vorgaben für Zeichensatz und Sortierfolge beim Erstellen aus dem Quellcode ändern wollen, verwenden Sie `--with-charset` und `--with-collation` als Argumente für configure. Zum Beispiel:

    shell> ./configure --with-charset=latin1

Oder:

    shell> ./configure --with-charset=latin1 \
               --with-collation=latin1_german1_ci

Sowohl mysqld als auch configure stellen sicher, dass die Kombination aus Zeichensatz und Sortierfolge gültig ist. Andernfalls zeigt jedes Programm eine Fehlermeldung an und wird dann beendet.

Die aktuellen Werte für Zeichensatz und Sortierfolge können den Systemvariablen `character_set_server` und `collation_server` entnommen werden. Diese Variablen lassen sich zur Laufzeit ändern.

### 10.3.2. Datenbankzeichensatz und -sortierfolge

Jede Datenbank hat einen datenbankspezifischen Zeichensatz und eine Datenbanksortierfolge. Die Anweisungen `CREATE DATABASE` und `ALTER DATABASE` bieten optionale Klauseln zur Angabe von Zeichensatz und Sortierfolge:

    CREATE DATABASE db_name
        [[DEFAULT] CHARACTER SET charset_name]
        [[DEFAULT] COLLATE collation_name]

    ALTER DATABASE db_name
        [[DEFAULT] CHARACTER SET charset_name]
        [[DEFAULT] COLLATE collation_name]

Statt `DATABASE` kann auch das Schlüsselwort `SCHEMA` verwendet werden.

Alle Datenbankoptionen werden in einer Textdatei namens `db.opt` gespeichert, die sich im Datenbankverzeichnis befindet.

Die Klauseln `CHARACTER SET` und `COLLATE` ermöglichen die Erstellung von Datenbanken mit unterschiedlichen Zeichensätzen und Sortierfolgen auf demselben MySQL Server.

Beispiel:

    CREATE DATABASE db_name CHARACTER SET latin1 COLLATE latin1_swedish_ci;

MySQL wählt Zeichensatz und Sortierfolge für die Datenbank auf folgende Weise:

- Wenn sowohl `CHARACTER SET `X`` als auch `COLLATE `Y`` angegeben werden, dann werden der Zeichensatz `X` und die Sortierfolge `Y` eingestellt.

- Wenn `CHARACTER SET `X`` ohne `COLLATE` angegeben wird, dann wird der Zeichensatz `X` mit seiner Standardsortierfolge eingestellt.

- Wenn `COLLATE `Y`` ohne `CHARACTER SET` angegeben wird, dann wird der mit `Y` verknüpfte Zeichensatz mit der Sortierfolge `Y` eingestellt.

- Andernfalls werden die Standardwerte für Zeichensatz und Sortierfolge eingestellt.

Datenbankzeichensatz und -sortierfolge werden als Standardwerte verwendet, wenn Zeichensatz und Sortierfolge für die Tabelle nicht in `CREATE TABLE`-Anweisungen angegeben werden. Einen anderen Zweck haben sie nicht.

Die Werte für Zeichensatz und Sortierfolge der Standarddatenbank können den Systemvariablen `character_set_database` und `collation_database` entnommen werden. Der Server stellt diese Variablen immer dann ein, wenn die Standarddatenbank sich ändert. Ist keine Standarddatenbank vorhanden, dann haben die Variablen denselben Wert wie die entsprechenden Systemvariablen für die Serverebene (`character_set_server` und `collation_server`).

### 10.3.3. Tabellenzeichensatz und -sortierfolge

Jede Tabelle hat einen tabellenspezifischen Zeichensatz und eine Tabellensortierfolge. Die Anweisungen `CREATE TABLE` und `ALTER TABLE` bieten optionale Klauseln zur Angabe von Zeichensatz und Sortierfolge:

    CREATE TABLE tbl_name (column_list)
        [[DEFAULT] CHARACTER SET charset_name] [COLLATE collation_name]]

    ALTER TABLE tbl_name
        [[DEFAULT] CHARACTER SET charset_name] [COLLATE collation_name]

Beispiel:

    CREATE TABLE t1 ( ... ) CHARACTER SET latin1 COLLATE latin1_danish_ci;

MySQL wählt Zeichensatz und Sortierfolge für die Tabelle auf folgende Weise:

- Wenn sowohl `CHARACTER SET `X`` als auch `COLLATE `Y`` angegeben werden, dann werden der Zeichensatz `X` und die Sortierfolge `Y` eingestellt.

- Wenn `CHARACTER SET `X`` ohne `COLLATE` angegeben wird, dann wird der Zeichensatz `X` mit seiner Standardsortierfolge eingestellt.

- Wenn `COLLATE `Y`` ohne `CHARACTER SET` angegeben wird, dann wird der mit `Y` verknüpfte Zeichensatz mit der Sortierfolge `Y` eingestellt.

- Andernfalls werden die datenbankspezifischen Standardwerte für Zeichensatz und Sortierfolge eingestellt.

Tabellenzeichensatz und -sortierfolge werden als Standardwerte verwendet, wenn Zeichensatz und Sortierfolge in den Definitionen einzelner Spalten nicht angegeben sind. Tabellenzeichensatz und -sortierfolge sind MySQL-Erweiterungen, die es im SQL-Standard nicht gibt.

### 10.3.4. Spaltenzeichensatz und -sortierfolge

Jede „Zeichenspalte“ (d. h. eine Spalte des Typs `CHAR`, `VARCHAR` oder `TEXT`) hat einen Spaltenzeichensatz und eine Spaltensortierfolge. Die Spaltendefinitionssyntax bietet optionale Klauseln zur Angabe von Spaltenzeichensatz und -sortierfolge:

    col_name {CHAR | VARCHAR | TEXT} (col_length)
        [CHARACTER SET charset_name [COLLATE collation_name]]

Beispiel:

    CREATE TABLE Table1
    (
        column1 VARCHAR(5) CHARACTER SET latin1 COLLATE latin1_german1_ci
    );

MySQL wählt Zeichensatz und Sortierfolge für eine Spalte auf folgende Weise:

- Wenn sowohl `CHARACTER SET `X`` als auch `COLLATE `Y`` angegeben werden, dann werden der Zeichensatz `X` und die Sortierfolge `Y` eingestellt.

- Wenn `CHARACTER SET `X`` ohne `COLLATE` angegeben wird, dann wird der Zeichensatz `X` mit seiner Standardsortierfolge eingestellt.

- Wenn `COLLATE `Y`` ohne `CHARACTER SET` angegeben wird, dann wird der mit `Y` verknüpfte Zeichensatz mit der Sortierfolge `Y` eingestellt.

- Andernfalls werden die tabellenspezifischen Standardwerte für Zeichensatz und Sortierfolge eingestellt.

Die Klauseln `CHARACTER SET` und `COLLATE` entsprechen dem SQL-Standard.

### 10.3.5. Zeichensatz und Sortierfolge literaler Strings

Jeder Zeichen-String-Literal hat einen Zeichensatz und eine Sortierfolge.

Ein String-Literal weist unter Umständen eine optionale Zeichensatzeinführung und eine `COLLATE`-Klausel auf:

    [_charset_name]'string' [COLLATE collation_name]

Ein paar Beispiele:

    SELECT 'string';
    SELECT _latin1'string';
    SELECT _latin1'string' COLLATE latin1_danish_ci;

Für die einfache Anweisung `SELECT '`string`'` werden Zeichensatz und Sortierfolge des Strings definiert von den Systemvariablen `character_set_connection` und `collation_connection`.

Der Ausdruck `_`charset_name`` heißt formal Einführung. Die Einführung zeigt dem Parser an, dass der nachfolgende String den Zeichensatz `X` verwendet. Da dies in der Vergangenheit zu Verwirrung bei Benutzern geführt hat, wollen wir an dieser Stelle betonen, dass eine Einführung keine Konvertierung zur Folge hat – es handelt sich lediglich um ein Signal, das den Wert des Strings nicht ändert. Eine Einführung ist auch zulässig vor der standardmäßigen und der numerischen hexadezimalen Literalnotation (`x'`literal`'` bzw. `0x`nnnn``) sowie vor `?` (Parameterersetzung bei der Verwendung vorbereiteter Anweisungen innerhalb einer Programmiersprachen-Schnittstelle).

Ein paar Beispiele:

    SELECT _latin1 x'AABBCC';
    SELECT _latin1 0xAABBCC;
    SELECT _latin1 ?;

MySQL wählt Zeichensatz und Sortierfolge eines Literals auf folgende Weise:

- Wenn sowohl `_X` als auch `COLLATE `Y`` angegeben werden, dann werden der Zeichensatz `X` und die Sortierfolge `Y` eingestellt.

- Wenn `_X` angegeben ist, `COLLATE` aber nicht, dann wird der Zeichensatz `X` mit der Standardsortierfolge verwendet.

- Andernfalls werden als Zeichensatz und Sortierfolge die Werte der Systemvariablen `character_set_connection` bzw. `collation_connection` gesetzt.

Ein paar Beispiele:

- Ein String mit dem Zeichensatz `latin1` und der Sortierfolge `latin1_german1_ci`:

      SELECT _latin1'Müller' COLLATE latin1_german1_ci;

- Ein String mit dem Zeichensatz `latin1` und der Standardsortierfolge (`latin1_swedish_ci`):

      SELECT _latin1'Müller';

- Ein String mit Standardzeichensatz und -sortierfolge der Verbindung:

      SELECT 'Müller';

Zeichensatzeinführungen und die `COLLATE`-Klausel sind entsprechend den Spezifikationen des SQL-Standards implementiert.

### 10.3.6. Nationaler Zeichensatz

Der SQL-Standard definiert `NCHAR` oder `NATIONAL CHAR` als Möglichkeit, anzugeben, dass eine `CHAR`-Spalte einen bestimmten vordefinierten Zeichensatz verwenden soll. MySQL 5.1 verwendet `utf8` als vordefinierten Zeichensatz. So sind beispielsweise die folgenden Datentypdeklarationen gleichwertig:

    CHAR(10) CHARACTER SET utf8
    NATIONAL CHARACTER(10)
    NCHAR(10)

Gleiches gilt für die folgenden:

    VARCHAR(10) CHARACTER SET utf8
    NATIONAL VARCHAR(10)
    NCHAR VARCHAR(10)
    NATIONAL CHARACTER VARYING(10)
    NATIONAL CHAR VARYING(10)

Sie können mit `N'`literal`'` einen String im Nationalzeichensatz erstellen. Die folgenden beiden Anweisungen sind äquivalent:

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

Informationen zur Aktualisierung von Zeichensätzen auf MySQL 5.1 von Versionen vor 4.1 finden Sie im MySQL-Referenzhandbuch für die Versionen 3.23, 4.0 und 4.1.

### 10.3.7. Beispiele für die Zuordnung von Zeichensatz und Sortierfolge

Die folgenden Beispiele zeigen, wie MySQL die Standardwerte für den Zeichensatz und die Sortierfolge ermittelt.

Beispiel 1: Tabellen- und Spaltendefinition

    CREATE TABLE t1
    (
        c1 CHAR(10) CHARACTER SET latin1 COLLATE latin1_german1_ci
    ) DEFAULT CHARACTER SET latin2 COLLATE latin2_bin;

Hier haben wir eine Spalte mit dem Zeichensatz `latin1` und der Sortierfolge `latin1_german1_ci`. Die Definition ist explizit, d. h., die Werte ergeben sich von selbst. Beachten Sie, dass das Speichern einer `latin1`-Spalte in einer `latin2`-Tabelle unproblematisch ist.

Beispiel 2: Tabellen- und Spaltendefinition

    CREATE TABLE t1
    (
        c1 CHAR(10) CHARACTER SET latin1
    ) DEFAULT CHARACTER SET latin1 COLLATE latin1_danish_ci;

Hier nun haben wir eine Spalte mit dem Zeichensatz `latin1` und der Standardsortierfolge. Obwohl es naheliegend erscheint, wird die Standardsortierfolge nicht von der Tabellenebene übernommen. Stattdessen hat, weil die Standardsortierfolge von `latin1` immer `latin1_swedish_ci` ist, die Spalte `c1` die Sortierfolge `latin1_swedish_ci` (und nicht `latin1_danish_ci`).

Beispiel 3: Tabellen- und Spaltendefinition

    CREATE TABLE t1
    (
        c1 CHAR(10)
    ) DEFAULT CHARACTER SET latin1 COLLATE latin1_danish_ci;

Hier haben wir eine Spalte mit den Standardwerten für Zeichensatz und Sortierfolge. Unter diesen Umständen bestimmt MySQL anhand der Angaben auf der Tabellenebene den Zeichensatz und die Sortierfolge für die Spalte. Es ergibt sich, dass der Zeichensatz `latin1` und die zugehörige Sortierfolge `latin1_danish_ci` für die Spalte `c1` eingestellt werden.

Beispiel 4: Datenbank-, Tabellen- und Spaltendefinition

    CREATE DATABASE d1
        DEFAULT CHARACTER SET latin2 COLLATE latin2_czech_ci;
    USE d1;
    CREATE TABLE t1
    (
        c1 CHAR(10)
    );

Wir erstellen eine Spalte ohne Angabe von Zeichensatz und Sortierfolge. Ebenso wenig geben wir einen Zeichensatz und eine Sortierfolge auf der Tabellenebene an. Unter diesen Umständen überprüft MySQL die Datenbankebene, um die Tabelleneinstellungen zu ermitteln, die daraufhin auch zu den Spalteneinstellungen werden. Es ergibt sich, dass der Zeichensatz `latin2` und die zugehörige Sortierfolge `latin2_czech_ci` für die Spalte `c1` eingestellt werden.

### 10.3.8. Kompatibilität mit anderen Datenbanksystemen

Aus Gründen der MaxDB-Kompatibilität sind die folgenden beiden Anweisungen gleichwertig:

    CREATE TABLE t1 (f1 CHAR(N) UNICODE);
    CREATE TABLE t1 (f1 CHAR(N) CHARACTER SET ucs2);

## 10.4. Verbindungszeichensatz und -sortierfolge

Verschiedene Systemvariablen zu Zeichensätzen und Sortierfolgen sind spezifisch für die Interaktion eines Clients mit dem Server. Einige dieser Variablen wurden bereits in früheren Abschnitten erwähnt:

- Die Werte für Zeichensatz und Sortierfolge können den Systemvariablen `character_set_server` und `collation_server` entnommen werden.

- Die Werte für Zeichensatz und Sortierfolge der Standarddatenbank können den Systemvariablen `character_set_database` und `collation_database` entnommen werden.

Weitere Systemvariablen zu Zeichensätzen und Sortierfolgen betreffen die Handhabung der Daten einer Verbindung zwischen einem Client und dem Server. Jeder Client hat verbindungsspezifische Systemvariablen für Zeichensatz und Sortierfolge.

Sehen wir uns doch einmal an, was eine „Verbindung“ ist: Sie stellen eine solche her, wenn Sie sich mit dem Server verbinden. Der Client sendet SQL-Anweisungen wie etwa Abfragen über die Verbindung an den Server. Der Server beantwortet diese, indem er beispielsweise Ergebnismengen über die Verbindung an den Client zurückschickt. Dies wirft eine Reihe von Fragen zum Umgang mit Zeichensatz und Sortierfolge bei Clientverbindungen auf, die sich aber alle auf der Basis von Systemvariablen beantworten lassen:

- Welchen Zeichensatz verwendet eine Anweisung, wenn sie den Client verlässt?

  Der Server entnimmt der Systemvariablen `character_set_client` den Zeichensatz, in dem sich vom Client gesendete Anweisungen befinden.

- In welchen Zeichensatz sollte der Server eine Anweisung übersetzen, nachdem er sie erhalten hat?

  Hierzu verwendet der Server die Systemvariablen `character_set_connection` und `collation_connection`. Er wandelt die Anweisungen, die vom Client gesendet wurden, aus `character_set_client` in `character_set_connection` um (ausgenommen hiervon sind String-Literale, die eine Einführung wie `_latin1` oder `_utf8` aufweisen). `collation_connection` ist wichtig für Vergleiche literaler Strings. Für Vergleiche von Strings mit Spaltenwerten ist `collation_connection` hingegen unerheblich, da Spalten eine eigene Sortierfolge haben, die in diesem Fall Vorrang hat.

- In welchen Zeichensatz soll der Server übersetzen, bevor er Ergebnismengen oder Fehlermeldungen an den Client zurückschickt?

  Die Systemvariable `character_set_results` gibt den Zeichensatz an, in dem der Server Abfrageergebnisse an den Client zurückgibt. Hierzu gehören Ergebnisdaten wie etwa Spaltenwerte und ergebnisbezogene Metadaten wie beispielsweise Spaltennamen.

Sie können die Einstellungen dieser Variablen optimieren oder einfach die Standardeinstellungen verwenden.

Es gibt zwei Anweisungen, die sich auf die Zeichensätze einer Verbindung auswirken:

    SET NAMES 'charset_name'
    SET CHARACTER SET charset_name

`SET NAMES` gibt an, welchen Zeichensatz der Client zum Versand von SQL-Anweisungen an den Server verwendet. `SET NAMES 'cp1251'` bedeutet mithin: „Ab jetzt haben von diesem Client eingehende Nachrichten den Zeichensatz `cp1251`“. Außerdem gibt die Anweisung den Zeichensatz an, den der Server zum Zurücksenden der Ergebnisse an den Client verwenden soll. (Beispielsweise legt er fest, welcher Zeichensatz für Spaltenwerte benutzt werden soll, wenn Sie eine `SELECT`-Anweisung absetzen.)

Eine `SET NAMES '`x`'`-Anweisung ist äquivalent zu den folgenden drei Anweisungen:

    SET character_set_client = x;
    SET character_set_results = x;
    SET character_set_connection = x;

Das Einstellen von `character_set_connection` auf `x` setzt `collation_connection` auf die Standardsortierfolge für `x`.

`SET CHARACTER SET` ähnelt `SET NAMES`, setzt Zeichensatz und Sortierfolge der Verbindung aber auf die Werte der Datenbank. Eine `SET CHARACTER SET `x``-Anweisung ist äquivalent zu den folgenden drei Anweisungen:

    SET character_set_client = x;
    SET character_set_results = x;
    SET collation_connection = @@collation_database;

Wenn Sie `collation_connection` einstellen, setzen Sie damit gleichzeitig `character_set_connection` auf den Zeichensatz, der mit dieser Sortierfolge verknüpft ist.

Wenn ein Client eine Verbindung herstellt, sendet er den Namen des Zeichensatzes, den er verwenden will, an den Server. Der Server stellt auf der Basis dieses Namens die Systemvariablen `character_set_client`, `character_set_results` und `character_set_connection` ein. Im Endeffekt führt der Server eine `SET NAMES`-Operation unter Verwendung des Zeichensatznamens aus.

Beim mysql-Client ist die Ausführung von `SET NAMES` bei jedem Systemstart nicht notwendig, wenn Sie einen anderen als den Standardzeichensatz verwenden wollen. Fügen Sie der mysql-Anweisungszeile oder Ihrer Optionsdatei einfach die Option `--default-character-set` hinzu. Die folgende Option beispielsweise setzt die drei Zeichensatzvariablen bei jedem Aufruf von mysql auf `koi8r`:

    [mysql]
    default-character-set=koi8r

Beispiel: Nehmen wir an, `column1` sei als `CHAR(5) CHARACTER SET latin2` definiert. Wenn Sie `SET NAMES` oder `SET CHARACTER SET` nicht angeben, dann sendet der Server bei `SELECT column1 FROM t` alle Werte für `column1` zurück und verwendet dazu den Zeichensatz, den der Client bei der Verbindungsherstellung angegeben hat. Im Gegensatz dazu konvertiert, wenn Sie `SET NAMES 'latin1'` oder `SET CHARACTER SET latin1` vor dem Absetzen der `SELECT`-Anweisung angeben, der Server die `latin2`-Werte in `latin1`, bevor er die Ergebnisse zurückschickt. Die Konvertierung kann verlustbehaftet sein, wenn Zeichen verwendet werden, die nicht in beiden Zeichensätzen vorhanden sind.

Wenn Sie nicht wollen, dass der Server Ergebnismengen konvertiert, dann setzen Sie `character_set_results` auf `NULL`:

    SET character_set_results = NULL;

Hinweis: Derzeit kann UCS-2 nicht als Clientzeichensatz verwendet werden, d. h., `SET NAMES 'ucs2'` funktioniert nicht.

Um die Werte der Zeichensatz- und Sortierfolgevariablen anzuzeigen, die für Ihre Verbindung gelten, verwenden Sie die folgenden Anweisungen:

    SHOW VARIABLES LIKE 'character_set%';
    SHOW VARIABLES LIKE 'collation%';

## 10.5. Probleme mit Sortierfolgen

Die folgenden Abschnitte beschreiben verschiedene Aspekte der Sortierfolgen bei Zeichensätzen.

### 10.5.1. Verwendung von `COLLATE` in SQL-Anweisungen

Mit der `COLLATE`-Klausel können Sie die Standardsortierfolge für einen Vergleich außer Kraft setzen. `COLLATE` kann in verschiedenen Teilen von SQL-Anweisungen verwendet werden. Hier ein paar Beispiele:

- Bei `ORDER BY`:

      SELECT k
      FROM t1
      ORDER BY k COLLATE latin1_german2_ci;

- Bei `AS`:

      SELECT k COLLATE latin1_german2_ci AS k1
      FROM t1
      ORDER BY k1;

- Bei `GROUP BY`:

      SELECT k
      FROM t1
      GROUP BY k COLLATE latin1_german2_ci;

- Bei Zusammenfassungsfunktionen:

      SELECT MAX(k COLLATE latin1_german2_ci)
      FROM t1;

- Bei `DISTINCT`:

      SELECT DISTINCT k COLLATE latin1_german2_ci
      FROM t1;

- Bei `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;

- Bei `HAVING`:

      SELECT k
      FROM t1
      GROUP BY k
      HAVING k = _latin1 'Müller' COLLATE latin1_german2_ci;

### 10.5.2. Rangfolgen von `COLLATE`-Klauseln

Die `COLLATE`-Klausel hat eine hohe Priorität (höher als `||`), d. h., die folgenden beiden Ausdrücke sind äquivalent:

    x || y COLLATE z
    x || (y COLLATE z)

### 10.5.3. Der `BINARY`-Operator

Der Operator `BINARY` wandelt den ihm nachfolgenden String in einen Binär-String um. Dies ist eine einfache Möglichkeit, einen Spaltenvergleich byte- statt zeichenweise durchzuführen. `BINARY` berücksichtigt auch am Ende stehende Leerzeichen.

    mysql> SELECT 'a' = 'A';
            -> 1
    mysql> SELECT BINARY 'a' = 'A';
            -> 0
    mysql> SELECT 'a' = 'a ';
            -> 1
    mysql> SELECT BINARY 'a' = 'a ';
            -> 0

`BINARY `str`` ist eine Abkürzung für `CAST(`str` AS BINARY)`.

Das Attribut `BINARY` in Zeichenspaltendefinitionen hat einen anderen Effekt. Einer Zeichenspalte, die mit dem Attribut `BINARY` definiert ist, wird die Binärsortierung des Zeichensatzes der Spalte zugewiesen. Jeder Zeichensatz hat eine Binärsortierfolge. So heißt etwa die Binärsortierung des Zeichensatzes `latin1` `latin1_bin`. Wenn also der Standardzeichensatz der Tabelle `latin1` ist, dann sind die folgenden beiden Definitionen äquivalent:

    CHAR(10) BINARY
    CHAR(10) CHARACTER SET latin1 COLLATE latin1_bin

Der Effekt von `BINARY` als Spaltenattribut unterscheidet sich von dessen Wirkungsweise vor MySQL 4.1. Ursprünglich führte `BINARY` zu einer Spalte, die als Binär-String behandelt wurde. Ein Binär-String ist ein String aus Bytes, der weder einen Zeichensatz noch eine Sortierfolge hat; hierin liegt der Unterschied zu einem nichtbinären Zeichen-String, der eine Binärsortierung hat. Bei beiden String-Typen basieren Vergleiche auf den numerischen Werten der String-Einheit, aber bei nichtbinären Strings ist die Einheit das Zeichen, und einige Zeichensätze unterstützen Multibytezeichen. Siehe Abschnitt 11.4.2, „Die `BINARY`- und `VARBINARY`-Typen“.

Die Verwendung von `CHARACTER SET binary` in der Definition einer `CHAR`-, `VARCHAR`- oder `TEXT`-Spalte bewirkt, dass diese als binärer Datentyp behandelt wird. So sind beispielsweise die folgenden Definitionspaare gleichwertig:

    CHAR(10) CHARACTER SET binary
    BINARY(10)

    VARCHAR(10) CHARACTER SET binary
    VARBINARY(10)

    TEXT CHARACTER SET binary
    BLOB

### 10.5.4. Spezialfälle, in denen die Festlegung der Sortierfolge problematisch ist

Bei der überwiegenden Mehrheit der Anweisungen ist offensichtlich, welche Sortierfolge MySQL zur Auflösung einer Vergleichsoperation verwendet. Beispielsweise sollte es in den folgenden Fällen klar sein, dass die Sortierfolge der Spalte `x` verwendet wird:

    SELECT x FROM T ORDER BY x;
    SELECT x FROM T WHERE x = x;
    SELECT DISTINCT x FROM T;

Wenn allerdings mehrere Operanden vorhanden sind, kann es zu Mehrdeutigkeiten kommen. Zum Beispiel:

    SELECT x FROM T WHERE x = 'Y';

Soll diese Abfrage die Sortierfolge der Spalte `x` oder die des String-Literals `'Y'` verwenden?

Der SQL-Standard löst solche Fragen mithilfe so genannter „Sortierfolgevorrangsregeln“. Im Grunde genommen bedeutet dies: Sowohl `x` als auch `'Y'` haben Sortierfolgen – welche Sortierfolge also hat Vorrang? Dies kann schwierig zu lösen sein, aber die folgenden Regeln sollten die meisten Situationen abdecken:

- Eine explizite `COLLATE`-Klausel hat einen Sortierfolgenvorrangswert von 0 (d. h. gar keinen Vorrang).

- Die Verkettung zweier Strings mit verschiedenen Sortierfolgen hat einen Sortierfolgenvorrangswert von 1.

- Die Verkettung einer Spalte, eines Parameters einer gespeicherten Routine oder einer lokalen Variablen hat einen Sortierfolgenvorrangswert von 2.

- Eine „Systemkonstante“ (d. h. der von Funktionen wie `USER()` oder `VERSION()` zurückgegebene String) hat einen Sortierfolgenvorrangswert von 3.

- Die Sortierfolge eines Literals hat einen Sortierfolgenvorrangswert von 4

- `NULL` oder ein Ausdruck, der von `NULL` abgeleitet ist, hat einen Sortierfolgenvorrangswert von 5.

Die genannten Sortierfolgenvorrangswerte gelten für MySQL 5.1.

Diese Regeln lösen Mehrdeutigkeiten wie folgt auf:

- Die Sortierfolge mit dem niedrigsten Sortierfolgenvorrangswert wird verwendet.

- Weisen beide Seiten hierfür denselben Wert auf, dann wird ein Fehler ausgegeben, wenn die Sortierfolgen nicht identisch sind.

Ein paar Beispiele:

`column1 = 'A'` | Verwendet die Sortierfolge von `column1`
`column1 = 'A' COLLATE x` | Verwendet die Sortierfolge von `'A'`
`column1 COLLATE x = 'A' COLLATE y` | Fehler

Mithilfe der Funktion `COERCIBILITY()` können Sie den Sortierfolgenvorrangswert eines String-Ausdrucks bestimmen:

    mysql> SELECT COERCIBILITY('A' COLLATE latin1_swedish_ci);
            -> 0
    mysql> SELECT COERCIBILITY(VERSION());
            -> 3
    mysql> SELECT COERCIBILITY('A');
            -> 4

Siehe auch Abschnitt 12.10.3, „Informationsfunktionen“.

### 10.5.5. Sortierfolgen müssen für den richtigen Zeichensatz angegeben werden

Jeder Zeichensatz hat eine oder mehrere Sortierfolgen, aber jede Sortierfolge ist nur mit genau einem Zeichensatz verknüpft. Insofern führt die folgende Anweisung zu einer Fehlermeldung, weil die Sortierfolge `latin2_bin` für den Zeichensatz `latin1` unzulässig ist:

    mysql> SELECT _latin1 'x' COLLATE latin2_bin;
    ERROR 1253 (42000): COLLATION 'latin2_bin' is not valid
    for CHARACTER SET 'latin1'

### 10.5.6. Beispiel für die Auswirkung von Sortierfolgen

Angenommen, die Spalte `X` in der Tabelle `T` hat die folgenden `latin1`-Spaltenwerte:

    Muffler
    Müller
    MX Systems
    MySQL

Nehmen wir nun weiter an, dass die Spaltenwerte mithilfe der folgenden Anweisung abgerufen werden:

    SELECT X FROM T ORDER BY X COLLATE collation_name;

Die folgende Tabelle zeigt die sich ergebende Reihenfolge der Werte, wenn wir `ORDER BY` mit verschiedenen Sortierfolgen verwenden:

`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

Das Zeichen, welches in diesem Fall die verschiedenen Sortierfolgen bewirkt, ist der deutsche Umlaut `ü`.

- Die erste Spalte zeigt das Ergebnis von `SELECT` unter Verwendung der schwedisch-finnischen Sortierfolgenregel, die besagt, dass Ü bei Y einsortiert wird.

- Die zweite Spalte zeigt das Ergebnis von `SELECT` unter Verwendung der deutschen Regel DIN-1, die besagt, dass Ü bei U einsortiert wird.

- Die dritte Spalte zeigt das Ergebnis von `SELECT` unter Verwendung der deutschen Regel DIN-2, die besagt, dass Ü bei UE einsortiert wird.

## 10.6. Operationen, auf die sich die Zeichensatzunterstützung auswirkt

Dieser Abschnitt beschreibt Operationen, die Zeichensatzinformationen berücksichtigen.

### 10.6.1. Ergebnis-Strings

MySQL hat viele Operatoren und Funktionen, die einen String zurückgeben. In diesem Abschnitt wollen wir die Frage beantworten, welchen Zeichensatz und welche Sortierfolge ein solcher String hat.

Bei einfachen Funktionen, die den String als Eingabe entgegennehmen und einen String als Ergebnis ausgeben, sind Zeichensatz und Sortierfolge des Ausgabe-Strings dieselben wie beim ersten Eingabewert. Beispielsweise gibt `UPPER(`X`)` einen String zurück, dessen Zeichensatz und Sortierfolge dieselben sind wie bei `X`. Gleiches gilt für `INSTR()`, `LCASE()`, `LOWER()`, `LTRIM()`, `MID()`, `REPEAT()`, `REPLACE()`, `REVERSE()`, `RIGHT()`, `RPAD()`, `RTRIM()`, `SOUNDEX()`, `SUBSTRING()`, `TRIM()`, `UCASE()` und `UPPER()`.

Hinweis: Anders als alle anderen Funktionen ignoriert die `REPLACE()`-Funktion stets die Sortierfolge des Eingabe-Strings und führt einen Vergleich mit Unterscheidung der Groß-/Kleinschreibung durch.

Wenn ein Eingabe-String oder ein Funktionsergebnis einen Binär-String zum Ergebnis haben, hat dieser String keinen Zeichensatz und keine Sortierfolge. Dies kann mithilfe der Funktionen `CHARSET()` und `COLLATION()` überprüft werden, die beide `binary` zurückgeben, wenn das Argument ein Binär-String ist:

    mysql> SELECT CHARSET(BINARY 'a'), COLLATION(BINARY 'a');
    +---------------------+-----------------------+
    | CHARSET(BINARY 'a') | COLLATION(BINARY 'a') |
    +---------------------+-----------------------+
    | binary              | binary                |
    +---------------------+-----------------------+

Bei Operationen, die mehrere Eingabe-Strings kombinieren und einen einzelnen Ausgabe-String zurückgeben, gelten die „Zusammenfassungsregeln“ des SQL-Standards zur Bestimmung der Sortierfolge des Ergebnisses:

- Wenn eine explizite `COLLATE `X`` vorhanden ist, wird `X` verwendet.

- Wenn explizite `COLLATE `X`` und `COLLATE `Y`` auftreten, wird ein Fehler zurückgegeben.

- Andernfalls wird, wenn alle Sortierfolgen `X` sind, `X` verwendet.

- Ansonsten hat das Ergebnis keine Sortierfolge.

Beispielsweise ist bei `CASE ... WHEN a THEN b WHEN b THEN c COLLATE `X` END` die resultierende Sortierfolge `X`. Gleiches gilt für `CASE`, `UNION`, `||`, `CONCAT()`, `ELT()`, `GREATEST()`, `IF()` und `LEAST()`.

Bei Operationen, die Zeichendaten umwandeln, werden der Zeichensatz und die Sortierfolge der Strings, die sich aus diesen Operationen ergeben, durch die Systemvariablen `character_set_connection` und `collation_connection` definiert. Dies gilt für `CAST()`, `CHAR()`, `CONV()`, `FORMAT()`, `HEX()` und `SPACE()`.

### 10.6.2. `CONVERT()` und `CAST()`

`CONVERT()` stellt eine Möglichkeit zur Konvertierung von Daten zwischen verschiedenen Zeichensätzen dar. Die Syntax sieht wie folgt aus:

    CONVERT(expr USING transcoding_name)

Bei MySQL sind die Transkodierungs- mit den entsprechenden Zeichensatznamen identisch.

Ein paar Beispiele:

    SELECT CONVERT(_latin1'Müller' USING utf8);
    INSERT INTO utf8table (utf8column)
        SELECT CONVERT(latin1field USING utf8) FROM latin1table;

`CONVERT(... USING ...)` ist entsprechend der SQL-Standardspezifikation implementiert.

Sie können auch mit `CAST()` einen String in einen anderen Zeichensatz umwandeln. Die Syntax sieht wie folgt aus:

    CAST(character_string AS character_data_type CHARACTER SET charset_name)

Beispiel:

    SELECT CAST(_latin1'test' AS CHAR CHARACTER SET utf8);

Wenn Sie `CAST()` ohne Angabe von `CHARACTER SET` verwenden, werden Zeichensatz und Sortierfolge des Ergebnisses durch die Systemvariablen `character_set_connection` und `collation_connection` definiert. Wenn Sie `CAST()` mit `CHARACTER SET X` benutzen, hat das Ergebnis den Zeichensatz `X` und als Sortierfolge die Standardsortierfolge von `X`.

Sie können eine `COLLATE`-Klausel nicht innerhalb, wohl aber außerhalb von `CAST()` verwenden. Mithin ist `CAST(... COLLATE ...)` unzulässig, `CAST(...) COLLATE ...` aber ist zulässig.

Beispiel:

    SELECT CAST(_latin1'test' AS CHAR CHARACTER SET utf8) COLLATE utf8_bin;

### 10.6.3. `SHOW`-Anweisungen und `INFORMATION_SCHEMA`

Mehrere `SHOW`-Anweisungen vermitteln zusätzliche Angaben zu Zeichensätzen. Hierzu gehören `SHOW CHARACTER SET`, `SHOW COLLATION`, `SHOW CREATE DATABASE`, `SHOW CREATE TABLE` und `SHOW COLUMNS`. Diese Anweisungen wollen wir hier kurz beschreiben. Weitere Informationen finden Sie unter Abschnitt 13.5.4, „`SHOW`“.

`INFORMATION_SCHEMA` gibt mehrere Tabellen aus, deren Inhalt dem ähnelt, was sich mit `SHOW`-Anweisungen anzeigen lässt. So enthalten beispielsweise die Tabellen `CHARACTER_SETS` und `COLLATIONS` die Angaben, die sich auch mit `SHOW CHARACTER SET` bzw. `SHOW COLLATION` ermitteln lassen. Siehe Kapitel 22, Die Datenbank `INFORMATION_SCHEMA`.

Der Befehl `SHOW CHARACTER SET` zeigt alle verfügbaren Zeichensätze an. Er nimmt eine optionale `LIKE`-Klausel entgegen, die angibt, auf welche Zeichensatznamen zu prüfen ist. Zum Beispiel:

    mysql> SHOW CHARACTER SET LIKE 'latin%';
    +---------+-----------------------------+-------------------+--------+
    | Charset | Description                 | Default collation | Maxlen |
    +---------+-----------------------------+-------------------+--------+
    | latin1  | cp1252 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 |
    +---------+-----------------------------+-------------------+--------+

Die Ausgabe von `SHOW COLLATION` enthält alle verfügbaren Zeichensätze. Die Anweisung nimmt eine optionale `LIKE`-Klausel entgegen, die angibt, auf welche Sortierfolgennamen zu prüfen ist. Zum Beispiel:

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

`SHOW CREATE DATABASE` zeigt die `CREATE DATABASE`-Anweisung an, die eine gegebene Datenbank erstellt:

    mysql> SHOW CREATE DATABASE test;
    +----------+-----------------------------------------------------------------+
    | Database | Create Database                                                 |
    +----------+-----------------------------------------------------------------+
    | test     | CREATE DATABASE `test` /*!40100 DEFAULT CHARACTER SET latin1 */ |
    +----------+-----------------------------------------------------------------+

Wird keine `COLLATE`-Klausel angezeigt, dann wird die Standardsortierfolge des Zeichensatzes verwendet.

`SHOW CREATE TABLE` ist ähnlich, zeigt aber die `CREATE TABLE`-Anweisung zur Erstellung der Tabelle an. Die Spaltendefinitionen enthalten alle ggf. vorhandenen Zeichensatzspezifikationen, und die Tabellenoptionen enthalten in jedem Fall Zeichensatzangaben.

Die `SHOW COLUMNS`-Anweisung zeigt die Sortierfolgen der Spalten einer Tabelle an, wenn sie mit `SHOW FULL COLUMNS` aufgerufen wird. Spalten der Datentypen `CHAR`, `VARCHAR` und `TEXT` haben Sortierfolgen. Numerische und andere nicht zeichenbasierte Typen haben keine Sortierfolge (dies wird durch `NULL` als `Collation`-Wert angezeigt). Zum Beispiel:

    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:

Der Zeichensatz erscheint nicht direkt in der Anzeige, wohl aber als Teil des Sortierfolgennamens.

## 10.7. Unicode-Unterstützung

MySQL 5.1 unterstützt zur Speicherung von Unicode-Daten zwei Zeichensätze:

- `ucs2` (Unicode-Zeichensatz UCS-2)

- `utf8` (UTF-8-Kodierung des Unicode-Zeichensatzes)

Bei UCS-2 (binäre Unicode-Darstellung) wird jedes Zeichen durch einen 2 Byte umfassenden Unicode-Code dargestellt, wobei das höherwertige Byte zuerst aufgeführt ist. Zum Beispiel: `LATIN CAPITAL LETTER A` hat den Code `0x0041` und wird als 2-Byte-Sequenz gespeichert: `0x00 0x41`. `CYRILLIC SMALL LETTER YERU` (Unicode `0x044B`) wird als 2-Byte-Sequenz gespeichert: `0x04 0x4B`. Weitere Informationen zu Unicode-Zeichen und ihren Codes erhalten Sie auf der Unicode-Homepage.

Derzeit kann UCS-2 nicht als Clientzeichensatz verwendet werden, d. h., `SET NAMES 'ucs2'` funktioniert nicht.

Der UTF-8-Zeichensatz (transformierte Unicode-Darstellung) ist eine alternative Möglichkeit zur Speicherung von Unicode-Daten. Er ist entsprechend RFC 3629 implementiert. Die Idee hinter dem UTF-8-Zeichensatz ist die, dass verschiedene Unicode-Zeichen mit Bytesequenzen unterschiedlicher Länge kodiert werden:

- Einfache lateinische Buchstaben, Ziffern und Interpunktionszeichen verwenden je ein Byte.

- Die Schriftzeichen der meisten europäischen und nahöstlichen Sprachen passen in eine 2-Byte-Sequenz. Dies gilt für die Buchstaben des erweiterten Lateins (einschließlich Tilde, Längestrich, Akut, Gravis und weitere Akzente) sowie das Kyrillische, Griechische, Armenische, Hebräische, Arabische, Syrische usw.

- Die koreanischen, chinesischen und japanischen Ideogramme schließlich verwenden je 3 Byte.

RFC 3629 beschreibt Sequenzen, die 1 bis 4 Byte umfassen. Zurzeit umfasst die UTF-8-Unterstützung durch MySQL keine 4-Byte-Sequenzen. (Ein älterer Standard für die UTF-8-Kodierung ist in RFC 2279 enthalten, wo UTF-8-Sequenzen mit einer Länge von bis zu 6 Byte beschrieben werden. RFC 3629 hat RFC 2279 ersetzt, weswegen Sequenzen mit 5 oder 6 Byte heute nicht mehr verwendet werden.)

Tipp: Um mit UTF-8 Speicher zu sparen, verwenden Sie `VARCHAR` statt `CHAR`. Andernfalls muss MySQL 3 Byte pro Zeichen in einer `CHAR CHARACTER SET utf8`-Spalte reservieren, da dies die maximale Länge ist. So muss MySQL etwa 30 Byte für eine `CHAR(10) CHARACTER SET utf8`-Spalte vorsehen.

## 10.8. UTF8 für Metadaten

Metadaten sind „Daten über Daten“. Alle Daten, die die Datenbank beschreiben – nicht aber solche, die in der Datenbank enthalten sind – bezeichnet man als Metadaten. Insofern sind etwa Spalten-, Datenbank-, Benutzer- und Versionsnamen sowie die meisten String-Ergebnisse aus `SHOW`-Anweisungen Metadaten. Dies gilt auch für die Inhalte von Tabellen in `INFORMATION_SCHEMA`, weil diese Tabellen per Definition Informationen zu Datenbankobjekten enthalten.

Die Darstellung von Metadaten muss den folgenden Anforderungen genügen:

- Alle Metadaten müssen im selben Zeichensatz stehen. Andernfalls würden weder die `SHOW`-Befehle noch `SELECT`-Anweisungen für Tabellen im `INFORMATION_SCHEMA` korrekt arbeiten, weil verschiedene Datensätze in derselben Spalte der Ergebnisse für diese Operationen in verschiedenen Zeichensätzen stehen würden.

- Metadaten müssen alle Zeichen in allen Sprachen enthalten. Andernfalls könnten Benutzer unter Umständen Spalten und Tabellen nicht in ihrer eigenen Sprache benennen.

Um beide Bedingungen zu erfüllen, speichert MySQL Metadaten in einem Unicode-Zeichensatz (nämlich UTF-8). Dies sorgt keinesfalls für Probleme, wenn Sie keine Buchstaben mit Akzent oder nichtlateinische Zeichen verwenden. Andernfalls aber sollten Sie berücksichtigen, dass Metadaten in UTF-8 stehen.

Die Anforderungen an Metadaten sehen vor, dass die Rückgabewerte der Funktionen `USER()`, `CURRENT_USER()`, `DATABASE()` und `VERSION()` standardmäßig den UTF-8-Zeichensatz verwenden; dies gilt auch für Synonyme wie `SESSION_USER()` und `SYSTEM_USER()`.

Der Server setzt die Systemvariable `character_set_system` auf den Namen des Metadaten-Zeichensatzes:

    mysql> SHOW VARIABLES LIKE 'character_set_system';
    +----------------------+-------+
    | Variable_name        | Value |
    +----------------------+-------+
    | character_set_system | utf8  |
    +----------------------+-------+

Die Speicherung von Metadaten unter Verwendung von Unicode hat nicht zur Folge, dass der Server Spaltenüberschriften und die Ergebnisse von `DESCRIBE`-Funktionen standardmäßig im durch `character_set_system` angegebenen Zeichensatz zurückgibt. Wenn Sie `SELECT column1 FROM t` verwenden, wird der Name `column1` selbst vom Server an den Client in dem Zeichensatz zurückgegeben, der vom Wert der Systemvariablen `character_set_results` angegeben wird (deren Standartwert ist `latin1`). Wenn Sie wollen, dass der Server Metadatenergebnisse in einem anderen Zeichensatz zurückgibt, erzwingen Sie mit der `SET NAMES`-Anweisung eine Zeichensatzkonvertierung am Server. `SET NAMES` stellt `character_set_results` und andere zugehörige Systemvariablen um. (Siehe auch Abschnitt 10.4, „Verbindungszeichensatz und -sortierfolge“.) Alternativ kann ein Clientprogramm die Konvertierung nach Empfang des Ergebnisses vom Server vornehmen. Die Konvertierung durch den Client ist effizienter, aber diese Option ist nicht immer verfügbar.

Wenn `character_set_results` den Wert `NULL` hat, wird keine Konvertierung durchgeführt und der Server gibt Metadaten im ursprünglichen (d. h. dem durch `character_set_system` angegebenen) Zeichensatz zurück.

Fehlermeldungen, die der Server an den Client zurückgibt, werden wie Metadaten automatisch in den Zeichensatz des Clients konvertiert.

Keine Sorge, wenn Sie (beispielsweise) die Funktion `USER()` für einen Vergleich oder eine Zuordnung innerhalb einer einzelnen Anweisung verwenden: MySQL führt die Konvertierung für Sie automatisch durch.

    SELECT * FROM Table1 WHERE USER() = latin1_column;

Dies funktioniert, weil der Inhalt von `latin1_column` vor dem Vergleich automatisch in UTF-8 konvertiert wird.

    INSERT INTO Table1 (latin1_column) SELECT USER();

Dies funktioniert, weil der Inhalt von `USER()` vor der Zuweisung automatisch in `latin1` konvertiert wird. Die automatische Konvertierung ist noch nicht vollständig implementiert, sollte aber in einer zukünftigen Version korrekt arbeiten.

Zwar ist die automatische Konvertierung nicht Bestandteil des SQL-Standards, aber das SQL-Standarddokument besagt, dass jeder Zeichensatz (hinsichtlich der unterstützten Zeichen) eine „Teilmenge“ von Unicode ist. Aufgrund des bekannten Prinzips „Was für eine übergeordnete Menge gilt, kann auch für eine Teilmenge gelten“ nehmen wir an, dass eine Sortierfolge für Unicode auch für Vergleiche mit Nicht-Unicode-Strings gelten kann.

## 10.9. Zeichensätze und Sortierfolgen, die MySQL unterstützt

MySQL unterstützt mehr als 70 Sortierfolgen für über 30 Zeichensätze. In diesem Abschnitt sind die Zeichensätze aufgelistet, die MySQL unterstützt. Es gibt einen Unterabschnitt für jede Gruppe zusammengehöriger Zeichensätze. Für jeden Zeichensatz werden die zulässigen Sortierfolgen aufgeführt.

Sie können die verfügbaren Zeichensätze und ihre jeweiligen Standardsortierfolgen jederzeit mit der Anweisung `SHOW CHARACTER SET` anzeigen:

    mysql> SHOW CHARACTER SET;
    +----------+-----------------------------+---------------------+
    | Charset  | Description                 | Default collation   |
    +----------+-----------------------------+---------------------+
    | big5     | Big5 Traditional Chinese    | big5_chinese_ci     |
    | dec8     | DEC West European           | dec8_swedish_ci     |
    | cp850    | DOS West European           | cp850_general_ci    |
    | hp8      | HP West European            | hp8_english_ci      |
    | koi8r    | KOI8-R Relcom Russian       | koi8r_general_ci    |
    | latin1   | cp1252 West European        | latin1_swedish_ci   |
    | latin2   | ISO 8859-2 Central European | latin2_general_ci   |
    | swe7     | 7bit Swedish                | swe7_swedish_ci     |
    | ascii    | US ASCII                    | ascii_general_ci    |
    | ujis     | EUC-JP Japanese             | ujis_japanese_ci    |
    | sjis     | Shift-JIS Japanese          | sjis_japanese_ci    |
    | hebrew   | ISO 8859-8 Hebrew           | hebrew_general_ci   |
    | tis620   | TIS620 Thai                 | tis620_thai_ci      |
    | euckr    | EUC-KR Korean               | euckr_korean_ci     |
    | koi8u    | KOI8-U Ukrainian            | koi8u_general_ci    |
    | gb2312   | GB2312 Simplified Chinese   | gb2312_chinese_ci   |
    | greek    | ISO 8859-7 Greek            | greek_general_ci    |
    | cp1250   | Windows Central European    | cp1250_general_ci   |
    | gbk      | GBK Simplified Chinese      | gbk_chinese_ci      |
    | latin5   | ISO 8859-9 Turkish          | latin5_turkish_ci   |
    | armscii8 | ARMSCII-8 Armenian          | armscii8_general_ci |
    | utf8     | UTF-8 Unicode               | utf8_general_ci     |
    | ucs2     | UCS-2 Unicode               | ucs2_general_ci     |
    | cp866    | DOS Russian                 | cp866_general_ci    |
    | keybcs2  | DOS Kamenicky Czech-Slovak  | keybcs2_general_ci  |
    | macce    | Mac Central European        | macce_general_ci    |
    | macroman | Mac West European           | macroman_general_ci |
    | cp852    | DOS Central European        | cp852_general_ci    |
    | latin7   | ISO 8859-13 Baltic          | latin7_general_ci   |
    | cp1251   | Windows Cyrillic            | cp1251_general_ci   |
    | cp1256   | Windows Arabic              | cp1256_general_ci   |
    | cp1257   | Windows Baltic              | cp1257_general_ci   |
    | binary   | Binary pseudo charset       | binary              |
    | geostd8  | GEOSTD8 Georgian            | geostd8_general_ci  |
    | cp932    | SJIS for Windows Japanese   | cp932_japanese_ci   |
    | eucjpms  | UJIS for Windows Japanese   | eucjpms_japanese_ci |
    +----------+-----------------------------+---------------------+

### 10.9.1. Unicode-Zeichensätze

MySQL umfasst zwei Unicode-Zeichensätze. Sie können mit diesen beiden Zeichensätzen Text in ca. 650 Sprachen speichern.

- Sortierfolgen für `ucs2` (UCS-2-Unicode):

  - `ucs2_bin`

  - `ucs2_czech_ci`

  - `ucs2_danish_ci`

  - `ucs2_esperanto_ci`

  - `ucs2_estonian_ci`

  - `ucs2_general_ci` (Standard)

  - `ucs2_hungarian_ci`

  - `ucs2_icelandic_ci`

  - `ucs2_latvian_ci`

  - `ucs2_lithuanian_ci`

  - `ucs2_persian_ci`

  - `ucs2_polish_ci`

  - `ucs2_roman_ci`

  - `ucs2_romanian_ci`

  - `ucs2_slovak_ci`

  - `ucs2_slovenian_ci`

  - `ucs2_spanish2_ci`

  - `ucs2_spanish_ci`

  - `ucs2_swedish_ci`

  - `ucs2_turkish_ci`

  - `ucs2_unicode_ci`

- Sortierfolgen für `utf8` (UTF-8-Unicode):

  - `utf8_bin`

  - `utf8_czech_ci`

  - `utf8_danish_ci`

  - `utf8_esperanto_ci`

  - `utf8_estonian_ci`

  - `utf8_general_ci` (Standard)

  - `utf8_hungarian_ci`

  - `utf8_icelandic_ci`

  - `utf8_latvian_ci`

  - `utf8_lithuanian_ci`

  - `utf8_persian_ci`

  - `utf8_polish_ci`

  - `utf8_roman_ci`

  - `utf8_romanian_ci`

  - `utf8_slovak_ci`

  - `utf8_slovenian_ci`

  - `utf8_spanish2_ci`

  - `utf8_spanish_ci`

  - `utf8_swedish_ci`

  - `utf8_turkish_ci`

  - `utf8_unicode_ci`

Die Sortierfolgen `ucs2_hungarian_ci` und `utf8_hungarian_ci` wurden in MySQL 5.1.5 hinzugefügt.

MySQL implementiert die Sortierfolge `utf8_unicode_ci` entsprechend dem UCA (Unicode Collation Algorithm, Unicode-Sortierfolgenalgorithmus), der unter http://www.unicode.org/reports/tr10/ beschrieben ist. Die Sortierfolge verwendet die UCA-Gewichtungsschlüssel nach Version 4.0.0 (siehe http://www.unicode.org/Public/UCA/4.0.0/allkeys-4.0.0.txt). Die folgende Beschreibung verwendet `utf8_unicode_ci`, gilt aber für `ucs2_unicode_ci` gleichermaßen.

Zurzeit bietet die Sortierfolge `utf8_unicode_ci` nur teilweise Unterstützung für den UCA. Einige Zeichen werden noch nicht unterstützt. Gleiches gilt für diakritische Zeichen. Dies betrifft in erster Linie das Vietnamesische und einige Minderheitensprachen in Russland wie etwa das Udmurtische, das Tatarische, das Baschkirische und Mari.

Die bedeutsamste Funktion in `utf8_unicode_ci` besteht darin, dass Erweiterungen unterstützt werden, d. h., wenn ein Zeichen mit einer Kombination anderer Zeichen gleichgesetzt wird. Beispielsweise wird im Deutschen und einigen anderen Sprachen ‘`ß`’ mit ‘`ss`’ gleichgesetzt.

`utf8_general_ci` ist eine ältere Sortierfolge, die Erweiterungen nicht unterstützt. Hier können nur 1 : 1-Vergleiche zwischen Zeichen durchgeführt werden: Vergleiche für die `utf8_general_ci`-Sortierfolge sind also schneller, aber unter Umständen weniger korrekt als Vergleiche für `utf8_unicode_ci`.

Die folgenden Gleichstellungen beispielsweise sind sowohl in `utf8_general_ci` als auch in `utf8_unicode_ci` zutreffend:

    Ä = A
    Ö = O
    Ü = U

Ein Unterschied zwischen den Sortierfolgen besteht darin, dass Folgendes für `utf8_general_ci` wahr ist:

    ß = s

Dagegen ist Folgendes für `utf8_unicode_ci` wahr:

    ß = ss

MySQL implementiert sprachspezifische Sortierfolgen für den `utf8`-Zeichensatz nur dann, wenn die Sortierung mit `utf8_unicode_ci` bei einer Sprache nicht gut funktioniert. So arbeitet `utf8_unicode_ci` etwa für das Deutsche oder das Französische einwandfrei, weswegen für diese beiden Sprachen keine `utf8`-Spezialsortierungen erforderlich sind.

Auch `utf8_general_ci` ist für Deutsch und Französisch weitgehend angemessen, nur wird hier ‘`ß`’ mit ‘`s`’ (statt ‘`ss`’) gleichgesetzt. Sofern es für Ihre Anwendung ausreichend sein sollte, sollten Sie `utf8_general_ci` verwenden, weil diese Sortierfolge schneller ist. Ansonsten benutzen Sie `utf8_unicode_ci`, denn diese Sortierfolge arbeitet exakter.

`utf8_swedish_ci` wurde wie andere sprachspezifische `utf8`-Sortierfolgen auch von `utf8_unicode_ci` abgeleitet und mit zusätzlichen Sprachregeln ergänzt. Beispielsweise funktioniert im Schwedischen die folgende Beziehung – etwas, das der deutsche oder französische Muttersprachler nicht erwarten würde:

    Ü = Y < Ö

Die Sortierfolgen `utf8_spanish_ci` und `utf8_spanish2_ci` entsprechen dem modernen bzw. dem traditionellen Spanisch. Bei beiden Sortierfolgen ist ‘`ñ`’ (n mit Tilde) ein separater Buchstabe zwischen ‘`n`’ und ‘`o`’. Ferner ist beim traditionellen Spanisch ‘`ch`’ ein separater Buchstabe zwischen ‘`c`’ und `d` und ‘`ll`’ ein separater Buchstabe zwischen ‘`l`’ und ‘`m`’.

### 10.9.2. Westeuropäische Zeichensätze

Westeuropäische Zeichensätze decken die meisten westeuropäischen Sprachen ab, so etwa Französisch, Spanisch, Katalanisch, Baskisch, Portugiesisch, Italienisch, Albanisch, Niederländisch, Deutsch, Dänisch, Schwedisch, Norwegisch, Finnisch, Färöisch, Isländisch, Irisch, Schottisch und Englisch.

- Sortierfolgen von `ascii` (US ASCII):

  - `ascii_bin`

  - `ascii_general_ci` (Standard)

- Sortierfolgen von `cp850` (DOS, westeuropäisch):

  - `cp850_bin`

  - `cp850_general_ci` (Standard)

- Sortierfolgen von `dec8` (DEC, westeuropäisch):

  - `dec8_bin`

  - `dec8_swedish_ci` (Standard)

- Sortierfolgen von `hp8` (HP, westeuropäisch):

  - `hp8_bin`

  - `hp8_english_ci` (Standard)

- Sortierfolgen von `latin1` (cp1252, westeuropäisch):

  - `latin1_bin`

  - `latin1_danish_ci`

  - `latin1_general_ci`

  - `latin1_general_cs`

  - `latin1_german1_ci`

  - `latin1_german2_ci`

  - `latin1_spanish_ci`

  - `latin1_swedish_ci` (Standard)

  `latin1` ist der Standardzeichensatz. `latin1` von MySQL entspricht dem Windows-Zeichensatz `cp1252`. Mithin ist er mit dem offiziellen `latin1` nach `ISO 8859-1` bzw. dem `latin1`-Zeichensatz der IANA (Internet Assigned Numbers Authority) identisch, aber der IANA-Zeichensatz behandelt die Codepunkte zwischen `0x80` und `0x9f` als „undefiniert“, während `cp1252` (und damit auch der `latin1`-Zeichensatz von MySQL) diesen Positionen Zeichen zuweist. So ist etwa `0x80` das Eurozeichen. Für die „undefinierten“ Einträge in `cp1252` übersetzt MySQL `0x81` in das Unicode-Zeichen `0x0081`, `0x8d` in `0x008d`, `0x8f` in `0x008f`, `0x90` in `0x0090` und `0x9d` in `0x009d`.

  Die Sortierfolge `latin1_swedish_ci` ist die Standardsortierfolge, die von der Mehrzahl der MySQL-Kunden wahrscheinlich verwendet wird. Obwohl häufig gesagt wird, dass sie auf den Sortierregeln für das Schwedische und das Finnische basiert, gibt es viele Schweden und Finnen, die dieser Aussage widersprechen.

  Die Sortierfolgen `latin1_german1_ci` und `latin1_german2_ci` basieren auf den DIN-1- und DIN-2-Normen. DIN ist das Deutsche Institut für Normung, also die deutsche Standardisierungsorganisation. DIN-1 heißt „Wörterbuchsortierung“, DIN-2 „Telefonbuchsortierung“.

  - Regeln für `latin1_german1_ci` (Wörterbuchsortierung):

        Ä = A
        Ö = O
        Ü = U
        ß = s

  - Regeln für `latin1_german2_ci` (Telefonbuchsortierung):

        Ä = AE
        Ö = OE
        Ü = UE
        ß = ss

  Bei der Sortierfolge `latin1_spanish_ci` ist ‘`ñ`’ ein separater Buchstabe zwischen ‘`n`’ und ‘`o`’.

- Sortierfolgen von `macroman` (Mac, westeuropäisch):

  - `macroman_bin`

  - `macroman_general_ci` (Standard)

- Sortierfolgen von `swe7` (Schwedisch, 7 Bit):

  - `swe7_bin`

  - `swe7_swedish_ci` (Standard)

### 10.9.3. Mitteleuropäische Zeichensätze

MySQL bietet in eingeschränktem Maße Unterstützung für die Zeichensätze, die in Tschechien, der Slowakei, Ungarn, Rumänien, Slowenien, Kroatien und Polen verwendet werden.

- Sortierfolgen von `cp1250` (Windows, mitteleuropäisch):

  - `cp1250_bin`

  - `cp1250_croatian_ci`

  - `cp1250_czech_cs`

  - `cp1250_general_ci` (Standard)

  - `cp1250_polish_ci`

- Sortierfolgen von `cp852` (DOS, mitteleuropäisch):

  - `cp852_bin`

  - `cp852_general_ci` (Standard)

- Sortierfolgen von `keybcs2` (DOS, Kamenicky-tschechoslowakisch):

  - `keybcs2_bin`

  - `keybcs2_general_ci` (Standard)

- Sortierfolgen von `latin2` (ISO 8859-2, mitteleuropäisch):

  - `latin2_bin`

  - `latin2_croatian_ci`

  - `latin2_czech_cs`

  - `latin2_general_ci` (Standard)

  - `latin2_hungarian_ci`

- Sortierfolgen von `macce` (Mac, mitteleuropäisch):

  - `macce_bin`

  - `macce_general_ci` (Standard)

### 10.9.4. Zeichensätze für Südeuropa und den Mittleren Osten

Zu den südeuropäischen und nahöstlichen Zeichensätzen, die von MySQL unterstützt werden, gehören das Armenische, das Arabische, das Georgische, das Griechische, das Hebräische und das Türkische.

- Sortierfolgen für `armscii8` (ARMSCII-8, armenisch):

  - `armscii8_bin`

  - `armscii8_general_ci` (Standard)

- Sortierfolgen von `cp1256` (Windows, arabisch):

  - `cp1256_bin`

  - `cp1256_general_ci` (Standard)

- Sortierfolgen von `geostd8` (GEOSTD8, georgisch):

  - `geostd8_bin`

  - `geostd8_general_ci` (Standard)

- Sortierfolgen von `greek` (ISO 8859-7, griechisch):

  - `greek_bin`

  - `greek_general_ci` (Standard)

- Sortierfolgen von `hebrew` (ISO 8859-8, hebräisch):

  - `hebrew_bin`

  - `hebrew_general_ci` (Standard)

- Sortierfolgen von `latin5` (ISO 8859-9, türkisch):

  - `latin5_bin`

  - `latin5_turkish_ci` (Standard)

### 10.9.5. Baltische Zeichensätze

Die baltischen Zeichensätze decken die estnische, die lettische und die litauische Sprache ab.

- Sortierfolgen von `cp1257` (Windows, baltisch):

  - `cp1257_bin`

  - `cp1257_general_ci` (Standard)

  - `cp1257_lithuanian_ci`

- Sortierfolgen von `latin7` (ISO 8859-13, baltisch):

  - `latin7_bin`

  - `latin7_estonian_cs`

  - `latin7_general_ci` (Standard)

  - `latin7_general_cs`

### 10.9.6. Kyrillische Zeichensätze

Die kyrillischen Zeichensätze und Sortierfolgen werden für das Weißrussische, das Bulgarische, das Russische und das Ukrainische verwendet.

- Sortierfolgen von `cp1251` (Windows, kyrillisch):

  - `cp1251_bin`

  - `cp1251_bulgarian_ci`

  - `cp1251_general_ci` (Standard)

  - `cp1251_general_cs`

  - `cp1251_ukrainian_ci`

- Sortierfolgen von `cp866` (DOS, russisch):

  - `cp866_bin`

  - `cp866_general_ci` (Standard)

- Sortierfolgen von `koi8r` (KOI8-R, Relcom, russisch):

  - `koi8r_bin`

  - `koi8r_general_ci` (Standard)

- Sortierfolgen von `koi8u` (KOI8-U, ukrainisch):

  - `koi8u_bin`

  - `koi8u_general_ci` (Standard)

### 10.9.7. Asiatische Zeichensätze

Die von uns unterstützten asiatischen Zeichensätze sind das Chinesische, das Japanische, das Koreanische und das Thailändische. Diese können sehr komplex sein. Beispielsweise müssen die chinesischen Zeichensätze Tausende verschiedener Zeichen zulassen. Weitere Informationen zu den Zeichensätzen `cp932` und `sjis` finden Sie in Abschnitt 10.9.7.1, „Der Zeichensatz `cp932`“.

- Sortierfolgen von `big5` (Big5, chinesisch traditionell):

  - `big5_bin`

  - `big5_chinese_ci` (Standard)

- Sortierfolgen von `cp932` (SJIS für Windows, japanisch):

  - `cp932_bin`

  - `cp932_japanese_ci` (Standard)

- Sortierfolgen von `eucjpms` (UJIS für Windows, japanisch):

  - `eucjpms_bin`

  - `eucjpms_japanese_ci` (Standard)

- Sortierfolgen von `euckr` (EUC-KR, koreanisch):

  - `euckr_bin`

  - `euckr_korean_ci` (Standard)

- Sortierfolgen von `gb2312` (GB2312, chinesisch vereinfacht):

  - `gb2312_bin`

  - `gb2312_chinese_ci` (Standard)

- Sortierfolgen von `gbk` (GBK, chinesisch vereinfacht):

  - `gbk_bin`

  - `gbk_chinese_ci` (Standard)

- Sortierfolgen von `sjis` (Shift-JIS, japanisch):

  - `sjis_bin`

  - `sjis_japanese_ci` (Standard)

- Sortierfolgen von `tis620` (TIS620, thailändisch):

  - `tis620_bin`

  - `tis620_thai_ci` (Standard)

- Sortierfolgen von `ujis` (EUC-JP, japanisch):

  - `ujis_bin`

  - `ujis_japanese_ci` (Standard)

#### 10.9.7.1. Der Zeichensatz `cp932`

Warum ist `cp932` erforderlich?

In MySQL entspricht der Zeichensatz `sjis` dem von der IANA definierten Zeichensatz `Shift_JIS`, der JIS X0201- und JIS X0208-Zeichen unterstützt. (Siehe auch http://www.iana.org/assignments/character-sets.)

Allerdings ist die Bedeutung von „SHIFT JIS“ als Begriff zu Beschreibungszwecken sehr vage geworden und umfasst häufig auch die Erweiterungen auf `Shift_JIS`, die von verschiedenen Anbietern definiert werden.

So ist beispielsweise das in japanischsprachigen Windows-Umgebungen verwendete „SHIFT JIS“ eine Microsoft-Erweiterung von `Shift_JIS`, deren exakter Name `Microsoft Windows Codepage : 932` oder `cp932` lautet. Neben den von `Shift_JIS` unterstützten Zeichen unterstützt `cp932` Erweiterungszeichen wie NEC-Sonderzeichen, NEC-Auswahl-/IBM-Erweiterungszeichen sowie IBM-Auswahlzeichen.

Viele japanische Benutzer haben Probleme mit diesen Erweiterungszeichen. Ursache hierfür sind die folgenden Faktoren:

- MySQL wandelt Zeichensätze automatisch um.

- Zeichensätze werden via Unicode (`ucs2`) konvertiert.

- Der Zeichensatz `sjis` unterstützt keine Konvertierung dieser Erweiterungszeichen.

- Es gibt mehrere Regeln für die Konvertierung aus dem so genannten „SHIFT JIS“ in Unicode, und je nach Konvertierungsregeln werden einige Zeichen anders in Unicode konvertiert. MySQL unterstützt nur eine dieser Regeln (diese wird weiter unten beschrieben).

Der MySQL-Zeichensatz `cp932` wurde entwickelt, um diese Probleme zu beseitigen.

Weil MySQL die Zeichensatzkonvertierung unterstützt, ist es wichtig, die beiden Zeichensätze `Shift_JIS` (IANA) und `cp932` in zwei verschiedene Zeichensätze aufzuteilen, weil diese unterschiedliche Konvertierungsregeln bieten.

Wie unterscheidet sich `cp932` von `sjis`?

Der Zeichensatz `cp932` unterscheidet sich von `sjis` wie folgt:

- `cp932` unterstützt NEC-Sonderzeichen, NEC-Auswahl-/IBM-Erweiterungszeichen sowie IBM-Auswahlzeichen.

- Einige `cp932`-Zeichen haben zwei verschiedene Codepunkte, die beide in denselben Unicode-Codepunkt konvertiert werden. Wenn Sie aus Unicode in `cp932` zurückkonvertieren, muss einer dieser beiden Codepunkte ausgewählt werden. Bei solchen „Roundtrip-Konvertierungen“ wird die von Microsoft empfohlene Regel verwendet. (Siehe auch http://support.microsoft.com/kb/170559/EN-US/.)

  Die Konvertierungsregel funktioniert wie folgt:

  - Wenn das Zeichen sowohl in JIS X 0208 als auch in den NEC-Sonderzeichen enthalten ist, wird der Codepunkt von JIS X 0208 verwendet.

  - Wenn das Zeichen sowohl in den NEC-Sonderzeichen als auch in den IBM-Auswahlzeichen enthalten ist, wird der Codepunkt für NEC-Sonderzeichen verwendet.

  - Wenn das Zeichen sowohl in den IBM-Auswahlzeichen als auch in den NEC-Auswahl-/IBM-Erweiterungszeichen enthalten ist, wird der Codepunkt für IBM-Erweiterungszeichen verwendet.

  Die unter http://www.microsoft.com/globaldev/reference/dbcs/932.htm gezeigte Tabelle enthält Informationen zu den Unicode-Werten der `cp932`-Zeichen. Bei `cp932`-Tabelleneinträgen mit Zeichen, unter denen eine vierstellige Zahl erscheint, stellt diese die entsprechende Unicode-Kodierung (`ucs2`) dar. Bei Tabelleneinträgen mit einem unterstrichenen zweistelligen Wert gibt es einen Bereich mit `cp932`-Zeichenwerten, die bei diesen beiden Stellen beginnen. Wenn Sie auf einen solchen Tabelleneintrag klicken, gelangen Sie auf eine Seite, auf der der Unicode-Wert für jedes `cp932`-Zeichen angezeigt wird, das mit diesen Stellen beginnt.

  Die folgenden Links verdienen Ihr besonderes Interesse. Sie entsprechen den Kodierungen der folgenden Zeichenbestände:

  - NEC-Sonderzeichen:

        http://www.microsoft.com/globaldev/reference/dbcs/932/932_87.htm

  - NEC-Auswahl-/IBM-Erweiterungszeichen:

        http://www.microsoft.com/globaldev/reference/dbcs/932/932_ED.htm
        http://www.microsoft.com/globaldev/reference/dbcs/932/932_EE.htm

  - IBM-Auswahlzeichen:

        http://www.microsoft.com/globaldev/reference/dbcs/932/932_FA.htm
        http://www.microsoft.com/globaldev/reference/dbcs/932/932_FB.htm
        http://www.microsoft.com/globaldev/reference/dbcs/932/932_FC.htm

- `cp932` unterstützt die Konvertierung benutzerdefinierter Zeichen in Kombination mit `eucjpms` und beseitigt die Probleme bei der `sjis`-/`ujis`-Konvertierung. Weitere Informationen erhalten Sie unter http://www.opengroup.or.jp/jvc/cde/sjis-euc-e.html.

- Bei einigen Zeichen ist die Konvertierung von und nach `ucs2` bei `sjis` und `cp932` unterschiedlich. Die folgenden Tabellen veranschaulichen diese Unterschiede.

  Konvertierung nach `ucs2`:

  `sjis`-/`cp932`-Wert | Konvertierung `sjis` nach `ucs2` | Konvertierung `cp932` nach `ucs2`
  5C | 005C | 005C
  7E | 007E | 007E
  815C | 2015 | 2015
  815F | 005C | FF3C
  8160 | 301C | FF5E
  8161 | 2016 | 2225
  817C | 2212 | FF0D
  8191 | 00A2 | FFE0
  8192 | 00A3 | FFE1
  81CA | 00AC | FFE2

  Konvertierung von `ucs2`:

  `ucs2`-Wert | Konvertierung `ucs2` nach `sjis` | Konvertierung `ucs2` nach `cp932`
  005C | 815F | 5C
  007E | 7E | 7E
  00A2 | 8191 | 3F
  00A3 | 8192 | 3F
  00AC | 81CA | 3F
  2015 | 815C | 815C
  2016 | 8161 | 3F
  2212 | 817C | 3F
  2225 | 3F | 8161
  301C | 8160 | 3F
  FF0D | 3F | 817C
  FF3C | 3F | 815F
  FF5E | 3F | 8160
  FFE0 | 3F | 8191
  FFE1 | 3F | 8192
  FFE2 | 3F | 81CA

Dies ist eine Übersetzung des MySQL-Referenzhandbuchs, das sich auf dev.mysql.com befindet. Das ursprüngliche Referenzhandbuch ist auf Englisch, und diese Übersetzung ist nicht notwendigerweise so aktuell wie die englische Ausgabe. Das vorliegende deutschsprachige Handbuch behandelt MySQL bis zur Version 5.1.

Zurück |  | Weiter
Kapitel 9. Sprachstruktur | Zum Anfang | Kapitel 11. Datentypen