Es folgt eine Übersicht zu den numerischen Datentypen. Weitere Informationen finden Sie unter Abschnitt 11.2, „Numerische Datentypen“. Die Speicheranforderungen für die Typen sind in Abschnitt 11.5, „Speicherbedarf von Spaltentypen“, beschrieben.

M zeigt die maximale Anzeigebreite an. Der höchste zulässige Wert ist 255. Die Anzeigebreite hat keinen Bezug zur Speichergröße oder zum zulässigen Wertebereich des betreffenden Typs (siehe auch Abschnitt 11.2, „Numerische Datentypen“).

Wenn Sie ZEROFILL für eine numerische Spalte angeben, fügt MySQL automatisch das Attribut UNSIGNED für die Spalte hinzu.

SERIAL ist ein Alias für BIGINT UNSIGNED NOT NULL AUTO_INCREMENT UNIQUE.

SERIAL DEFAULT VALUE ist in der Definition einer Integer-Spalte ein Alias für NOT NULL AUTO_INCREMENT UNIQUE.

Warnung: Wenn Sie die Subtraktion für Integer-Werte verwenden, von denen einer vom Typ UNSIGNED ist, dann hat das Ergebnis kein Vorzeichen. Siehe auch Abschnitt 12.8, „Cast-Funktionen und Operatoren“.

Es folgt eine Übersicht über die zeitbezogenen Datentypen. Weitere Informationen finden Sie unter Abschnitt 11.3, „Datums- und Zeittypen“. Die Speicheranforderungen für die Typen sind in Abschnitt 11.5, „Speicherbedarf von Spaltentypen“, beschrieben.

Die Zusammenfassungsfunktionen SUM() und AVG() funktionieren bei Zeitwerten nicht. (Sie konvertieren die Werte in Zahlen, wodurch alles, was nach dem ersten nichtnumerischen Zeichen auftaucht, verloren geht.) Um dieses Problem zu umgehen, können Sie die Werte in numerische Einheiten konvertieren, dann die Zusammenfassungsfunktion ausführen und abschließend eine Rückkonvertierung in den Zeitwert durchführen. Ein paar Beispiele:

SELECT SEC_TO_TIME(SUM(TIME_TO_SEC(time_col))) FROM tbl_name;
SELECT FROM_DAYS(SUM(TO_DAYS(date_col))) FROM tbl_name;

Es folgt eine Übersicht über die String-Datentypen. Weitere Informationen finden Sie unter Abschnitt 11.4, „String-Typen“. Die Speicheranforderungen für die Typen sind in Abschnitt 11.5, „Speicherbedarf von Spaltentypen“, beschrieben.

Seit MySQL 4.1 weisen die String-Typen eine Reihe von Funktionen auf, die Sie, wenn Sie bislang nur mit älteren MySQL-Versionen (vor 4.1) gearbeitet haben, unter Umständen nicht kennen:

Kapitel 10, Zeichensatz-Unterstützung, enthält weitere Informationen zur Verwendung von Zeichensätzen in MySQL.

Die Klausel DEFAULT value in der Spezifikation eines Datentyps gibt einen Vorgabewert für eine Spalte an. Mit einer Ausnahme muss der Vorgabewert immer eine Konstante sein. Funktionen oder Ausdrücke sind als Vorgaben nicht zulässig. Das bedeutet, dass Sie beispielsweise als Vorgabewert einer Datumsspalte nicht den Wert einer Funktion wie NOW() oder CURRENT_DATE angeben dürfen. Die genannte Ausnahme besteht darin, dass Sie CURRENT_TIMESTAMP als Vorgabe für eine TIMESTAMP-Spalte festlegen können. Siehe auch Abschnitt 11.3.1.1, „TIMESTAMP-Eigenschaften ab MySQL 4.1“.

Für BLOB- und TEXT-Spalten können keine Vorgaben festgelegt werden.

Wenn eine Spaltendefinition keinen expliziten DEFAULT-Wert enthält, bestimmt MySQL diesen wie folgt:

Wenn die Spalte NULL als Wert annehmen kann, wird sie mit einer expliziten DEFAULT NULL-Klausel definiert.

Kann die Spalte NULL nicht als Wert annehmen, dann definiert MySQL die Spalte ohne explizite DEFAULT-Klausel. Wenn bei der Dateneingabe eine INSERT- oder REPLACE-Anweisung keinen Wert für die Spalte enthält, verarbeitet MySQL sie entsprechend dem zum betreffenden Zeitpunkt gültigen SQL-Modus:

Nehmen wir einmal an, eine Tabelle t sei wie folgt definiert:

CREATE TABLE t (i INT NOT NULL);

In diesem Fall hat i keinen expliziten Vorgabewert, d. h., im strikten Modus würde jede der folgenden Anweisungen einen Fehler erzeugen, und es würde kein Datensatz eingefügt. Wird der strikte Modus nicht verwendet, dann erzeugt nur die dritte Anweisung einen Fehler; bei den ersten beiden Anweisungen wird die implizite Vorgabe eingefügt, die dritte Anweisung schlägt hingegen fehl, weil DEFAULT(i) keinen Wert erzeugen kann:

INSERT INTO t VALUES();
INSERT INTO t VALUES(DEFAULT);
INSERT INTO t VALUES(DEFAULT(i));

Siehe auch Abschnitt 5.2.5, „Der SQL-Modus des Servers“.

Sie können für eine gegebene Tabelle die Anweisung SHOW CREATE TABLE verwenden, um anzuzeigen, welche Spalten eine explizite DEFAULT-Klausel aufweisen.

Die Typen DATETIME, DATE und TIMESTAMP gehören zusammen. In diesem Abschnitt werden ihre Eigenschaften sowie Gemeinsamkeiten und Unterschiede beschrieben.

Den Typ DATETIME verwenden Sie, wenn Sie Werte benötigen, die sowohl ein Datum als auch eine Uhrzeit enthalten. MySQL ruft DATETIME-Werte im Format 'YYYY-MM-DD HH:MM:SS' ab und zeigt sie auch so an. Der unterstützte Bereich liegt zwischen '1000-01-01 00:00:00' und '9999-12-31 23:59:59'. („Unterstützt“ bedeutet hier, dass früher liegende Werte zwar funktionieren können, dies aber nicht garantiert ist.)

Der Typ DATE erlaubt die Benutzung eines Datums ohne Zeitangabe. MySQL ruft DATE-Werte im Format 'YYYY-MM-DD' ab und zeigt sie auch so an. Der unterstützte Bereich liegt zwischen '1000-01-01' und '9999-12-31'.

Der Datentyp TIMESTAMP schließlich hat je nach MySQL-Version und SQL-Modus des Servers verschiedene Eigenschaften, die im Verlauf dieses Abschnitts noch beschrieben werden.

Sie können DATETIME-, DATE- und TIMESTAMP-Werte mit einem der folgenden gängigen Formate angeben:

Unzulässige DATETIME-, DATE- oder TIMESTAMP-Werte werden in den „Nullwert“ des entsprechenden Typs umgewandelt ('0000-00-00 00:00:00' oder '0000-00-00').

Bei als Strings angegebenen Werten, die Trennzeichen für Datumsbestandteile enthalten, ist es nicht erforderlich, zwei Stellen für Monats- oder Tageswerte anzugeben, die kleiner als 10 sind. So wird etwa '1979-6-9' als '1979-06-09' ausgewertet. Ähnlich ist es bei als Strings angegebenen Werten, die Trennzeichen für Uhrzeitbestandteile enthalten, nicht erforderlich, zwei Stellen für Stunden-, Minuten oder Sekundenwerte anzugeben, die kleiner als 10 sind: '1979-10-30 01:02:03' ist das Gleiche wie '1979-10-30 1:2:3'.

Als Zahlen angegebene Werte sollten eine Länge von 6, 8, 12 oder 14 Stellen haben. Wenn eine Zahl 8 oder 14 Stellen lang ist, werden die Formate YYYYMMDD bzw. YYYYMMDDHHMMSS angenommen, wobei das Jahr durch die ersten vier Stellen angegeben wird. Umfasst die Zahl 6 oder 12 Stellen, dann werden die Formate YYMMDD bzw. YYMMDDHHMMSS angenommen, wobei das Jahr durch die ersten beiden Stellen angegeben ist. Zahlen, die eine andere Länge aufweisen, werden so interpretiert, als ob sie am Anfang mit Nullen auf die nächste Länge aufgefüllt würden.

Werte, die als Strings ohne Trennzeichen angegeben werden, werden entsprechend ihrer Länge interpretiert. Ist der String 8 oder 14 Zeichen lang, dann wird angenommen, dass die ersten vier Zeichen das Jahr angeben. Andernfalls wird die Jahresangabe durch die ersten zwei Zeichen erwartet. Der String wird von links nach rechts interpretiert, als Reihenfolge wird Jahr, Monat, Tag, Stunde, Minute und Sekunde angenommen – je nachdem, wie viele Bestandteil im String vorhanden sind. Das bedeutet, dass Sie niemals Strings mit weniger als sechs Zeichen verwenden sollten. Wenn Sie beispielsweise '9903' angeben, um den März 1999 darzustellen, dann fügt MySQL einen „Nullwert“ für das Datum in Ihre Tabelle ein. Dies geschieht, weil die Jahres- und Monatsangaben 99 bzw. 03 sind, der Tag aber vollständig fehlt: Der Wert ist kein gültiges Datum. Sie können jedoch ausdrücklich einen Wert Null zur Darstellung fehlender Monats- oder Tagesangaben spezifizieren. So können Sie etwa '990300' verwenden, um den Wert '1999-03-00' einzufügen.

Sie können bis zu einem gewissen Grad Werte eines Datumstyps einem Objekt zuweisen, welches von einem anderen Datumstyp ist. Allerdings kann es hierdurch zu Werteänderungen oder Datenverlust kommen:

Beachten Sie die folgenden Widrigkeiten bei der Angabe von Datumswerten:

mysql> SET GLOBAL sql_mode=MAXDB;

mysql> SET SESSION sql_mode=MAXDB;

CREATE TABLE t
(
  ts1 TIMESTAMP NULL DEFAULT NULL,
  ts2 TIMESTAMP NULL DEFAULT 0,
  ts3 TIMESTAMP NULL DEFAULT CURRENT_TIMESTAMP
);

CREATE TABLE t (ts TIMESTAMP NULL DEFAULT CURRENT_TIMESTAMP);

CREATE TABLE t1 (ts TIMESTAMP NULL DEFAULT NULL);
CREATE TABLE t2 (ts TIMESTAMP NULL DEFAULT '0000-00-00 00:00:00');

INSERT INTO t1 VALUES (NOW());
INSERT INTO t2 VALUES (CURRENT_TIMESTAMP);

Abruf und Anzeige von TIME-Werten durch MySQL erfolgen im Format 'HH:MM:SS' (oder im Format 'HHH:MM:SS' bei einer großen Zahl von Stunden). TIME-Werte liegen in einem Bereich zwischen '-838:59:59' und '838:59:59'. Der Stundenteil kann so groß sein, weil TIME nicht nur eine Uhrzeit darstellen kann (diese muss kleiner sein als 24 Stunden), sondern auch die verstrichene Zeit oder ein Zeitintervall zwischen zwei Ereignissen. Ein solches Intervall kann wesentlich länger als 24 Stunden oder sogar negativ sein.

Zur Angabe von TIME-Werten steht eine Vielzahl von Formaten zur Verfügung:

Bei als String angegebenen TIME-Werten, die Trennzeichen für Uhrzeitbestandteile enthalten, ist es nicht erforderlich, zwei Stellen für Stunden-, Minuten oder Sekundenwerte anzugeben, die kleiner als 10 sind: '8:3:2' ist das Gleiche wie '08:03:02'.

Seien Sie vorsichtig bei der Zuweisung abgekürzter Werte zu einer TIME-Spalte. Ohne Doppelpunkte interpretiert MySQL die Werte in der Annahme, dass die beiden ganz rechts stehenden Stellen die Sekunden angeben. (MySQL interpretiert TIME-Werte nicht als Uhrzeit, sondern als verstrichene Zeit.) So könnte man etwa annehmen, dass '1112' und 1112 die Bedeutung '11:12:00' (also 12 Minuten nach 11 Uhr) hätten; MySQL liest die Angabe jedoch als '00:11:12' (also 11 Minuten und 12 Sekunden). Ähnlich werden '12' und 12 als '00:00:12' interpretiert. TIME-Werte mit Doppelpunkten hingegen werden immer als Uhrzeit betrachtet: '11:12' bedeutet also '11:12:00' und nicht '00:11:12'.

Standardmäßig werden Werte, die außerhalb des für TIME zulässigen Bereichs liegen, aber ansonsten zulässig sind, auf den nächstgelegenen Endpunkt des Bereichs gesetzt. Beispielsweise werden '-850:00:00' und '850:00:00' zu '-838:59:59' bzw. '838:59:59' konvertiert. Unzulässige TIME-Werte werden zu '00:00:00' konvertiert. Beachten Sie, dass es, weil '00:00:00' selbst ein zulässiger TIME-Wert ist, keine Möglichkeit gibt, festzustellen, ob ein in der Tabelle gespeicherter Wert '00:00:00' als '00:00:00' oder als unzulässiger Wert angegeben wurde.

Zur restriktiveren Behandlung ungültiger TIME-Werte aktivieren Sie den strikten SQL-Modus. In diesem Fall werden Fehler ausgegeben. Siehe auch Abschnitt 5.2.5, „Der SQL-Modus des Servers“.

Der Datentyp YEAR hat genau ein Byte und dient der Darstellung von Jahreszahlen.

MySQL ruft YEAR-Werte im Format YYYY ab und zeigt sie auch so an. Der Bereich liegt zwischen 1901 und 2155.

Zur Angabe von YEAR-Werten steht eine Vielzahl von Formaten zur Verfügung:

Unzulässige YEAR-Werte werden zu 0000 konvertiert.

Wie in Abschnitt 1.4.5, „Jahr-2000-Konformität“, beschrieben, ist MySQL selbst Jahr-2000-sicher; bestimmte Werte, die in MySQL eingegeben werden, sind es jedoch unter Umständen nicht. Jeder Wert, der eine zweistellige Jahresangabe enthält, ist mehrdeutig, da das Jahrhundert unbekannt ist. Solche Werte müssen in das vierstellige Format umgesetzt werden, da MySQL Jahreszahlen intern vierstellig speichert.

Bei den Typen DATETIME, DATE, TIMESTAMP und YEAR interpretiert MySQL nicht eindeutige Jahreszahlen entsprechend den folgenden Regeln:

Denken Sie daran, dass diese Regeln nur heuristischer Natur sind und sinnvoll zu erschließen versuchen, was Ihr Datenwert bedeuten könnte. Wenn die von MySQL verwendeten Regeln keine korrekten Werte erzeugen, sollten Sie eindeutige Angaben mit vierstelligen Jahreszahlen machen.

ORDER BY sortiert zweistellige YEAR-Werte wie erwartet.

Einige Funktionen wie MIN() und MAX() konvertieren einen YEAR-Wert in eine Zahl. Das bedeutet, dass ein Wert mit einer zweistelligen Jahresangabe für diese Funktionen ungeeignet ist. Dieses Problem beheben Sie, indem Sie den TIMESTAMP- oder YEAR-Wert in das vierstellige Jahresformat konvertieren.

Die Typen CHAR und VARCHAR ähneln einander, werden aber auf unterschiedliche Weise gespeichert und abgerufen. Weitere Unterschiede sind die maximale Länge und die Behandlung von Leerzeichen am String-Ende. Beim Speichern und Abrufen solcher Werte erfolgt keine Wandlung der Groß-/Kleinschreibung.

Die Typen CHAR und VARCHAR werden unter Angabe einer Länge deklariert, die die maximale Anzahl von Zeichen spezifiziert, die gespeichert werden kann. So kann ein CHAR(30)-Wert beispielsweise 30 Zeichen aufnehmen.

Die Länge einer CHAR-Spalte ist auf den von Ihnen beim Anlegen der Tabelle deklarierten Wert beschränkt. Dieser kann zwischen 0 und 255 liegen. Wenn CHAR-Werte gespeichert werden, dann werden sie nach rechts mit Leerzeichen bis auf die angegebene Länge aufgefüllt. Beim Abrufen von CHAR-Werten werden die am Ende stehenden Leerzeichen dann entfernt.

Werte in VARCHAR-Spalten sind Strings variabler Länge. Diese kann zwischen 0 und 65.535 liegen. (Die effektive Maximallänge einer VARCHAR-Spalte wird durch die maximale Datensatzgröße und den verwendeten Zeichensatz bestimmt. Die gesamte Maximallänge liegt bei 65.532 Byte.)

Im Gegensatz zu CHAR- werden VARCHAR-Werte nur mit so vielen Zeichen wie erforderlich zuzüglich eines Bytes gespeichert, welches die Länge angibt (bei Spalten, die mit einer Länge größer 255 deklariert sind, werden hierfür 2 Byte verwendet).

VARCHAR-Werte werden beim Speichern nicht aufgefüllt. Ferner werden am Ende stehende Leerzeichen entsprechend dem SQL-Standard beim Speichern und Abrufen beibehalten.

Wenn Sie einer CHAR- oder VARCHAR-Spalte einen Wert zuweisen, der die deklarierte Länge der Spalte überschreitet, dann wird der Wert so weit gekürzt, bis er passend ist. Handelt es sich bei den abgeschnittenen Zeichen nicht um Leerzeichen, dann wird eine Warnung erzeugt. Wenn Sie den strikten SQL-Modus verwenden, erscheint beim Abschneiden von anderen Zeichen als Leerzeichen eine Fehlermeldung (statt einer Warnung), und der Wert wird nicht eingefügt. Siehe auch Abschnitt 5.2.5, „Der SQL-Modus des Servers“.

Die folgende Tabelle veranschaulicht die Unterschiede zwischen den Typen CHAR und VARCHAR. Hierzu wird das jeweilige Ergebnis der Speicherung verschiedener String-Werte in CHAR(4)- und VARCHAR(4)-Spalten angezeigt:

Beachten Sie, dass die in der letzten Zeile der Tabelle gezeigten Werte nur gelten, wenn der strikte Modus nicht verwendet wird; wird MySQL hingegen im strikten Modus ausgeführt, dann werden Werte, die die Spaltenlänge überschreiten, nicht gespeichert, und ein Fehler wird ausgegeben.

Wird ein gegebener Wert in die Spalten CHAR(4) und VARCHAR(4) gespeichert, dann sind die aus den Spalten abgerufenen Werte nicht immer identisch, weil in CHAR-Spalten am Ende stehende Leerzeichen beim Abrufen entfernt werden. Das folgende Beispiel veranschaulicht diesen Unterschied:

mysql> CREATE TABLE vc (v VARCHAR(4), c CHAR(4));
Query OK, 0 rows affected (0.01 sec)

mysql> INSERT INTO vc VALUES ('ab  ', 'ab  ');
Query OK, 1 row affected (0.00 sec)

mysql> SELECT CONCAT('(', v, ')'), CONCAT('(', c, ')') FROM vc;
+---------------------+---------------------+
| CONCAT('(', v, ')') | CONCAT('(', c, ')') |
+---------------------+---------------------+
| (ab  )              | (ab)                |
+---------------------+---------------------+
1 row in set (0.06 sec)

Werte in CHAR- und VARCHAR-Spalten werden entsprechend der zeichensatzspezifischen Sortierungsweise, die der Spalte zugewiesen ist, sortiert und verglichen.

Beachten Sie, dass alle MySQL-Sortierungen vom Typ PADSPACE sind, d. h. alle CHAR- und VARCHAR-Werte in MySQL werden ohne Berücksichtigung der am Ende stehenden Leerzeichen verglichen. Zum Beispiel:

mysql> CREATE TABLE names (myname CHAR(10), yourname VARCHAR(10));
Query OK, 0 rows affected (0.09 sec)

mysql> INSERT INTO names VALUES ('Monty ', 'Monty ');
Query OK, 1 row affected (0.00 sec)

mysql> SELECT myname = 'Monty  ', yourname = 'Monty  ' FROM names;
+--------------------+----------------------+
| myname = 'Monty  ' | yourname = 'Monty  ' |
+--------------------+----------------------+
|                  1 |                    1 |
+--------------------+----------------------+
1 row in set (0.00 sec)

Dies gilt für alle MySQL-Versionen ungeachtet des gewählten SQL-Modus.

Bei solchen Fällen, in denen Leerzeichen am Ende entfernt werden oder Vergleiche diese ignorieren, hat, wenn eine Spalte einen Index hat, der eindeutige Werte erfordert, das Einfügen von Werten, die sich nur durch die Anzahl am Ende stehender Füllleerzeichen unterscheiden, eine Fehlermeldung bezüglich einer Schlüsseldublette zur Folge. Wenn beispielsweise eine Tabelle den Wert 'a' enthält, wird diese Fehlermeldung erzeugt, sobald Sie versuchen, 'a ' zu speichern.

Die Typen BINARY und VARBINARY ähneln CHAR bzw. VARCHAR. Der Unterschied besteht darin, dass diese beiden Typen binäre (statt nichtbinärer) Strings speichern, d. h., sie enthalten byte- statt zeichenbasierter Strings. Diese Datentypen haben aufgrund dessen keinen Zeichensatz: Sortierung und Vergleiche basieren in diesem Fall auf den numerischen Werten der Bytes in den Werten.

Die zulässige Maximallänge von BINARY und VARBINARY entspricht der von CHAR bzw. VARCHAR, nur wird die Länge von BINARY und VARBINARY in Bytes statt in Zeichen angegeben.

Die Datentypen BINARY und VARBINARY sind nicht identisch mit den Typen CHAR BINARY und VARCHAR BINARY Bei Letzteren hat das Attribut BINARY nicht zur Folge, dass die Spalte als binäre String-Spalte behandelt wird. Stattdessen aktiviert sie die binäre Sortierung für den Spaltenzeichensatz, und die Spalte selbst enthält nichtbinäre zeichenbasierte Strings statt binärer bytebasierter Strings. So wird beispielsweise CHAR(5) BINARY als CHAR(5) CHARACTER SET latin1 COLLATE latin1_bin behandelt (vorausgesetzt, der Standardzeichensatz ist latin1). Hier liegt ein Unterschied zu BINARY(5) vor, das binäre Strings mit einer Länge von 5 Byte speichert, für die kein Zeichensatz und keine Sortierung definiert sind.

Wenn BINARY-Werte gespeichert werden, werden sie nach rechts hin mit dem Füllwert auf die gewünschte Länge aufgefüllt. Der Füllwert ist 0x00 (das Nullbyte). Beim Einfügen werden Werte nach rechts hin mit 0x00 aufgefüllt, und beim Auswählen werden am Ende stehende Nullbytes nicht entfernt. Alle Bytes werden in Vergleichen (einschließlich ORDER BY- und DISTINCT-Operationen) berücksichtigt. 0x00-Bytes und Leerzeichen sind in Vergleichen unterschiedlich, wobei 0x00 einen kleineren Wert als das Leerzeichen hat.

Beispiel: Bei einer BINARY(3)-Spalte wird 'a ' beim Einfügen zu 'a \0'. 'a\0' wird beim Einfügen zu 'a\0\0'. Bei der Auswahl bleiben die gewählten Werte unverändert.

Bei VARBINARY werden weder beim Einfügen Füllbytes angehängt noch bei der Auswahl Bytes abgeschnitten. Alle Bytes werden in Vergleichen (einschließlich ORDER BY- und DISTINCT-Operationen) berücksichtigt. 0x00-Bytes und Leerzeichen sind in Vergleichen unterschiedlich, wobei 0x00 einen kleineren Wert als das Leerzeichen hat.

Bei solchen Fällen, in denen Füllbytes am Ende entfernt werden oder Vergleiche diese ignorieren, hat, wenn eine Spalte einen Index hat, der eindeutige Werte erfordert, das Einfügen von Werten, die sich nur durch die Anzahl am Ende stehender Füllbytes unterscheiden, eine Fehlermeldung bezüglich einer Schlüsseldublette zur Folge. Wenn beispielsweise eine Tabelle den Wert 'a' enthält, wird diese Fehlermeldung erzeugt, sobald Sie versuchen, 'a\0' zu speichern.

Wenn Sie den Datentyp BINARY zur Speicherung binärer Daten verwenden wollen und es wichtig ist, dass der abgerufene mit dem zuvor gespeicherten Wert vollständig identisch ist, dann sollten Sie die beschriebenen Merkmale zum Auffüllen und Abschneiden sorgfältig lesen. Das folgende Beispiel veranschaulicht, wie sich das Auffüllen von BINARY-Werten mit 0x00 auf Vergleiche von Spaltenwerten auswirkt:

mysql> CREATE TABLE t (c BINARY(3));
Query OK, 0 rows affected (0.01 sec)

mysql> INSERT INTO t SET c = 'a';
Query OK, 1 row affected (0.01 sec)

mysql> SELECT HEX(c), c = 'a', c = 'a\0\0' from t;
+--------+---------+-------------+
| HEX(c) | c = 'a' | c = 'a\0\0' |
+--------+---------+-------------+
| 610000 |       0 |           1 |
+--------+---------+-------------+
1 row in set (0.09 sec)

Wenn der abgerufene Wert mit dem zur Speicherung angegebenen Wert identisch sein muss, ohne dass aufgefüllt wird, dann sollten Sie unter Umständen besser VARBINARY oder einen der BLOB-Datentypen verwenden.

Ein BLOB ist ein binäres großes Objekt, welches eine variable Menge von Daten aufnehmen kann. Die vier BLOB-Typen sind TINYBLOB, BLOB, MEDIUMBLOB und LONGBLOB. Sie unterscheiden sich lediglich in der maximalen Länge der Werte, die sie aufnehmen können. Die vier TEXT-Typen sind TINYTEXT, TEXT, MEDIUMTEXT und LONGTEXT. Sie entsprechen den vier BLOB-Typen, d. h., sie haben dieselben Längenbeschränkungen und Speicheranforderungen. Siehe auch Abschnitt 11.5, „Speicherbedarf von Spaltentypen“. Beim Speichern und Abrufen von TEXT- und BLOB-Spalten erfolgt keine Wandlung der Groß-/Kleinschreibung.

BLOB-Spalten werden als binäre Strings (Byte-Strings) behandelt, TEXT-Spalten als nichtbinäre Strings (zeichenbasierte Strings). BLOB-Spalten haben keinen Zeichensatz, und die Sortierung basiert auf den numerischen Werten der Bytes in den Spaltenwerten; TEXT-Spalten hingegen haben einen Zeichensatz, dessen Sortierung auch bestimmt, wie die Werte sortiert und verglichen werden.

Wird eine TEXT-Spalte indiziert, dann werden Vergleiche von Indexeinträgen am Ende mit Leerzeichen aufgefüllt. Das bedeutet, dass, wenn der Index eindeutige Werte erfordert, Fehlermeldungen zu doppelt vorhandenen Schlüsseln auftreten werden, wenn sich Werte lediglich in der Anzahl der am Ende stehenden Leerzeichen unterscheiden. Wenn beispielsweise eine Tabelle den Wert 'a' enthält, wird diese Fehlermeldung erzeugt, sobald Sie versuchen, 'a ' zu speichern. Für BLOB-Spalten trifft dies allerdings nicht zu.

Wenn Sie im strikten Modus einer BLOB- oder TEXT-Spalte einen Wert zuweisen, der die zulässige Länge des Datentyps überschreitet, dann wird der Wert so weit gekürzt, bis er passend ist. Handelt es sich bei den abgeschnittenen Zeichen nicht um Leerzeichen, dann wird eine Warnung erzeugt. Wenn Sie den strikten SQL-Modus verwenden, erscheint stattdessen eine Fehlermeldung, und der Wert wird nicht eingefügt. Siehe auch Abschnitt 5.2.5, „Der SQL-Modus des Servers“.

In vielerlei Hinsicht können Sie eine BLOB-Spalte als VARBINARY-Spalte betrachten, die beliebig groß sein kann. Ähnlich können Sie eine TEXT-Spalte auch als VARCHAR-Spalte betrachten. BLOB und TEXT unterscheiden sich wie folgt von VARBINARY bzw. VARCHAR:

LONG und LONG VARCHAR lassen sich dem Datentyp MEDIUMTEXT zuordnen. Grund hierfür sind Kompatibilitätsaspekte. Wenn Sie das Attribut BINARY mit einem TEXT-Datentyp verwenden, wird der Spalte die binäre Sortierung des Spaltenzeichensatzes zugewiesen.

MySQL Connector/ODBC definiert BLOB-Werte als LONGVARBINARY und TEXT-Werte als LONGVARCHAR-Werte.

Da BLOB- und TEXT-Werte sehr lang sein können, können Sie bei ihrer Verwendung auf einige Einschränkungen treffen:

Jeder BLOB- und TEXT-Wert wird intern durch ein separat reserviertes Objekt dargestellt. Dies steht im Gegensatz zu allen anderen Datentypen, für die der Speicherplatz pro Spalte genau einmal beim Öffnen der Tabelle reserviert wird.

In manchen Fällen kann es wünschenswert sein, Binärdaten wie Mediendateien in BLOB- oder TEXT-Spalten zu speichern. Beim Umgang mit solchen Daten können sich die MySQL-Funktionen zur String-Verarbeitung als recht praktisch erweisen. Siehe auch Abschnitt 12.3, „String-Funktionen“. Aus Sicherheits- und anderen Gründen empfiehlt es sich in der Regel, dies im Anwendungscode zu tun, statt Benutzern der Anwendung die Berechtigung FILE zu gewähren. Details zu Sprachen und Plattformen können Sie in den MySQL-Foren (http://forums.mysql.com/) diskutieren.

Der Datentyp ENUM ist ein String-Objekt mit einem Wert, der aus einer Liste zulässiger Werte ausgewählt wird, die beim Erstellen der Tabelle explizit in der Spaltendefinition aufgelistet werden.

Als Werte kommen unter bestimmten Umständen auch der Leer-String ('') oder NULL in Frage:

Jeder Wert in der Auflistung hat einen Index:

Eine Spalte, die als ENUM('one', 'two', 'three') definiert ist, kann jeden der nachfolgend angegebenen Werte annehmen. Auch die Indizes der einzelnen Werte werden angezeigt:

Eine Auflistung darf maximal 65.535 Elemente enthalten.

Beim Erstellen der Tabelle werden bei ENUM-Mitgliedswerten am Ende stehende Leerzeichen in der Tabellendefinition automatisch entfernt.

Beim Abrufen werden Werte, die in einer ENUM-Spalte gespeichert sind, in der Groß-/Kleinschreibung angezeigt, die bei der Spaltendefinition verwendet wurde. Beachten Sie, dass ENUM-Spalten ein Zeichensatz und eine Sortierung zugewiesen werden können. Bei binären Sortierungen oder solchen, bei denen die Groß-/Kleinschreibung unterschieden wird, wird die Schreibweise beim Zuweisen von Werten zur Spalte berücksichtigt.

Wenn Sie einen ENUM-Wert in einem numerischen Kontext abrufen, wird der Index des Spaltenwerts zurückgegeben. So können Sie beispielsweise numerische Werte wie folgt aus einer ENUM-Spalte abrufen:

mysql> SELECT enum_col+0 FROM tbl_name;

Wenn Sie eine Zahl in einer ENUM-Spalte ablegen, wird diese als Index behandelt, und der mit diesem Index verknüpfte Mitgliedswert wird in der Spalte gespeichert. (Allerdings funktioniert dies nicht bei LOAD DATA, weil diese Anweisung alle Eingaben als Strings behandelt.) Es ist nicht ratsam, eine ENUM-Spalte mit Auflistungswerten zu definieren, die wie Zahlen aussehen, da dies schnell zu Verwirrung führen kann. So hat beispielsweise die folgende Spalte Auflistungswerte mit den String-Werten '0', '1' und '2', aber die numerischen Indexwerte 1, 2 und 3:

numbers ENUM('0','1','2')

ENUM-Werte werden entsprechend der Reihenfolge sortiert, in der sie in der Spaltendefinition aufgeführt wurden. (Anders gesagt: ENUM-Werte werden nach ihren Indexzahlen sortiert.) So wird beispielsweise bei ENUM('a', 'b') 'a' vor 'b' einsortiert, bei ENUM('b', 'a') hingegen wird 'b' vor 'a' einsortiert. Der Leer-String wird immer vor nichtleeren Strings einsortiert, und NULL-Werte werden vor allen anderen Auflistungswerten einsortiert. Um unerwünschte Ergebnisse zu vermeiden, geben Sie die ENUM-Liste am besten in alphabetischer Reihenfolge an. Sie können auch mit GROUP BY CAST(col AS CHAR) oder GROUP BY CONCAT(col) sicherstellen, dass die Spalte lexikalisch statt nach Indexnummer sortiert wird.

Wenn Sie alle möglichen Werte für eine ENUM-Spalte bestimmen wollen, verwenden Sie SHOW COLUMNS FROM tbl_name LIKE enum_col und verarbeiten die ENUM-Definition in der Spalte Type der Ausgabe.

Der Datentyp SET (Menge) ist ein String-Objekt, das null oder mehr Werte haben kann. Alle diese Werte entstammen einer Liste zulässiger Werte, die beim Erstellen der Tabelle angegeben werden. Bei SET-Spaltenwerten, die mehrere Mitglieder der Menge umfassen, werden die Mitgliedswerte durch Kommata (‘,’) getrennt angegeben. Hieraus ergibt sich, dass SET-Mitgliedswerte ihrerseits keine Kommata enthalten sollten.

Eine Spalte, die als SET('one', 'two') NOT NULL definiert ist, kann jeden der folgenden Werte annehmen:

''
'one'
'two'
'one,two'

Ein SET kann maximal 64 Mitgliedswerte umfassen.

Beim Erstellen der Tabelle werden bei SET-Mitgliedswerten am Ende stehende Leerzeichen in der Tabellendefinition automatisch entfernt.

Beim Abrufen werden Werte, die in einer SET-Spalte gespeichert sind, in der Groß-/Kleinschreibung angezeigt, die bei der Spaltendefinition verwendet wurde. Beachten Sie, dass SET-Spalten ein Zeichensatz und eine Sortierung zugewiesen werden können. Bei binären Sortierungen oder solchen, bei denen die Groß-/Kleinschreibung unterschieden wird, wird die Schreibweise beim Zuweisen von Werten zur Spalte berücksichtigt.

MySQL speichert SET-Werte numerisch, wobei das niederwertige Bit des gespeicherten Werts dem ersten Mitgliedswert der Menge entspricht. Wenn Sie einen SET-Wert in einem numerischen Kontext abrufen, sind die Bits dieses Werts entsprechend den Mitgliedswerten der Menge gesetzt, die den Spaltenwert bilden. So können Sie beispielsweise numerische Werte wie folgt aus einer SET-Spalte abrufen:

mysql> SELECT set_col+0 FROM tbl_name;

Wenn eine Zahl in einer SET-Spalte gespeichert wird, bestimmen die Bits, die in der Binärform der Zahl gesetzt sind, die im Spaltenwert vorhandenen Mitglieder. Bei einer Spalte, die als SET('a','b','c','d') definiert ist, haben die Mitglieder die folgenden Dezimal- und Binärwerte:

Wenn Sie dieser Spalte den Wert 9 zuweisen, entspricht dies dem Binärwert 1001, d. h., der erste und der vierte SET-Mitgliedswert ('a' und 'd') werden ausgewählt. Das Ergebnis lautet also 'a,d'.

Bei einem Wert, der mehr als ein SET-Element enthält, spielt es keine Rolle, in welcher Reihenfolge die Elemente beim Einfügen des Werts aufgeführt sind. Ebenso wenig ist relevant, wie häufig ein gegebenes Element in der Liste auftaucht. Wenn der Wert später abgerufen wird, erscheint jedes Element des Werts genau einmal in der Liste, und diese ist in der Reihenfolge sortiert, in der die Mitglieder bei Erstellung der Tabelle aufgeführt wurden. Nehmen wir beispielsweise einmal an, eine Spalte sei als SET('a','b','c','d') definiert:

mysql> CREATE TABLE myset (col SET('a', 'b', 'c', 'd'));

Nun fügen Sie die Werte 'a,d', 'd,a', 'a,d,d', 'a,d,a' und 'd,a,d' ein:

mysql> INSERT INTO myset (col) VALUES 
-> ('a,d'), ('d,a'), ('a,d,a'), ('a,d,d'), ('d,a,d');
Query OK, 5 rows affected (0.01 sec)
Records: 5  Duplicates: 0  Warnings: 0

Beim Abrufen erscheinen alle diese Werte als 'a,d':

mysql> SELECT col FROM myset;
+------+
| col  |
+------+
| a,d  |
| a,d  |
| a,d  |
| a,d  |
| a,d  |
+------+
5 rows in set (0.04 sec)

Wenn Sie eine SET-Spalte auf einen nicht unterstützten Wert setzen, wird dieser ignoriert, und es wird eine Warnung ausgegeben:

mysql> INSERT INTO myset (col) VALUES ('a,d,d,s');
Query OK, 1 row affected, 1 warning (0.03 sec)

mysql> SHOW WARNINGS;
+---------+------+------------------------------------------+
| Level   | Code | Message                                  |
+---------+------+------------------------------------------+
| Warning | 1265 | Data truncated for column 'col' at row 1 |
+---------+------+------------------------------------------+
1 row in set (0.04 sec)

mysql> SELECT col FROM myset;
+------+
| col  |
+------+
| a,d  |
| a,d  |
| a,d  |
| a,d  |
| a,d  |
| a,d  |
+------+
6 rows in set (0.01 sec)

Wenn der strikte SQL-Modus aktiviert ist, führen Versuche, ungültige SET-Werte einzufügen, zu einer Fehlermeldung.

SET-Werte werden numerisch sortiert. NULL-Werte werden dabei vor Nicht-NULL-Werten einsortiert.

Meist werden Sie SET-Werte mithilfe der Funktion FIND_IN_SET() oder des Operators LIKE durchsuchen:

mysql> SELECT * FROM tbl_name WHERE FIND_IN_SET('value',set_col)>0;
mysql> SELECT * FROM tbl_name WHERE set_col LIKE '%value%';

Die erste Anweisung findet Datensätze, bei denen set_col den Mitgliedswert value enthält. Die zweite ist ähnlich, aber nicht identisch: Sie findet Datensätze, bei denen set_col value an beliebiger Stelle (auch als Teil-String eines anderen Mitglieds) enthält.

Die folgenden Anweisungen sind ebenfalls zulässig:

mysql> SELECT * FROM tbl_name WHERE set_col & 1;
mysql> SELECT * FROM tbl_name WHERE set_col = 'val1,val2';

Die erste Anweisung sucht nach Werten, die das erste Mitglied der Menge enthalten. Die zweite sucht nach einer exakten Übereinstimmung. Seien Sie bei Vergleichen des zweiten Typs vorsichtig. Der Vergleich von Mengenwerten mit 'val1,val2' gibt andere Resultate zurück als der Vergleich mit 'val2,val1'. Sie sollten die Werte in derselben Reihenfolge angeben, in der sie in der Spaltendefinition aufgelistet sind.

Wenn Sie alle möglichen Werte für eine SET-Spalte bestimmen wollen, verwenden Sie SHOW COLUMNS FROM tbl_name LIKE set_col und verarbeiten die SET-Definition in der Spalte Type der Ausgabe.