MySQL 5.1 Reference Manual (Online Help)

Die einfachste Form von SELECT ruft alle in der Tabelle vorhandenen Daten ab:

mysql> SELECT * FROM pet;
+----------+--------+---------+------+------------+------------+
| name     | owner  | species | sex  | birth      | death      |
+----------+--------+---------+------+------------+------------+
| Fluffy   | Harold | cat     | f    | 1993-02-04 | NULL       |
| Claws    | Gwen   | cat     | m    | 1994-03-17 | NULL       |
| Buffy    | Harold | dog     | f    | 1989-05-13 | NULL       |
| Fang     | Benny  | dog     | m    | 1990-08-27 | NULL       |
| Bowser   | Diane  | dog     | m    | 1979-08-31 | 1995-07-29 |
| Chirpy   | Gwen   | bird    | f    | 1998-09-11 | NULL       |
| Whistler | Gwen   | bird    | NULL | 1997-12-09 | NULL       |
| Slim     | Benny  | snake   | m    | 1996-04-29 | NULL       |
| Puffball | Diane  | hamster | f    | 1999-03-30 | NULL       |
+----------+--------+---------+------+------------+------------+

Diese Verwendung von SELECT ist nützlich, wenn Sie beispielsweise Ihre Tabelle überprüfen wollen, nachdem Sie gerade die ersten Daten eingeladen haben. Nehmen wir etwa an, dass Sie nicht ganz sicher sind, ob Sie für Bowser das richtige Geburtsdatum eingegeben haben. Dem Stammbaum entnehmen Sie, dass das korrekte Geburtsjahr nicht 1979, sondern 1989 lautet.

Nun gibt es zwei Möglichkeiten, den Fehler zu beheben:

Wie im vorherigen Abschnitt gezeigt, ist das Abrufen der Daten einer ganzen Tabelle recht einfach. Sie lassen einfach die WHERE-Klausel in der SELECT-Anweisung weg. In der Regel wollen Sie aber nicht die gesamte Tabelle anzeigen – insbesondere dann nicht, wenn diese sehr groß ist. Stattdessen werden Sie meist an der Beantwortung einer bestimmten Frage interessiert sein. In diesem Fall müssen Sie Beschränkungen für die gewünschten Daten definieren. Betrachten wir einmal einige Auswahlabfragen dahingehend, welche Fragen diese zu Ihren Haustieren beantworten.

Sie können die Auswahl in Ihrer Tabelle auch auf bestimmte Datensätze beschränken. Wollen Sie z. B. die Änderungen am Geburtsdatum von Bowser überprüfen, dann wählen Sie den entsprechenden Datensatz wie folgt aus:

mysql> SELECT * FROM pet WHERE name = 'Bowser';
+--------+-------+---------+------+------------+------------+
| name   | owner | species | sex  | birth      | death      |
+--------+-------+---------+------+------------+------------+
| Bowser | Diane | dog     | m    | 1989-08-31 | 1995-07-29 |
+--------+-------+---------+------+------------+------------+

Die Ausgabe bestätigt die korrekte Änderung der Jahresangabe von 1979 auf 1989.

Bei String-Vergleichen wird die Groß-/Kleinschreibung normalerweise ignoriert, weswegen Sie den Namen als 'bowser', 'BOWSER' usw. angeben können. Das Abfrageergebnis ist stets gleich.

Sie können Bedingungen aber nicht nur für name, sondern für jede beliebige Spalte angeben. Wenn Sie beispielsweise wissen wollen, welche Tiere im Jahre 1998 oder danach geboren wurden, testen Sie die Spalte geburtstag:

mysql> SELECT * FROM pet WHERE birth >= '1998-1-1';
+----------+-------+---------+------+------------+-------+
| name     | owner | species | sex  | birth      | death |
+----------+-------+---------+------+------------+-------+
| Chirpy   | Gwen  | bird    | f    | 1998-09-11 | NULL  |
| Puffball | Diane | hamster | f    | 1999-03-30 | NULL  |
+----------+-------+---------+------+------------+-------+

Sie können auch Bedingungen kombinieren, um etwa nach weiblichen Hunden zu suchen:

mysql> SELECT * FROM pet WHERE species = 'dog' AND sex = 'f';
+-------+--------+---------+------+------------+-------+
| name  | owner  | species | sex  | birth      | death |
+-------+--------+---------+------+------------+-------+
| Buffy | Harold | dog     | f    | 1989-05-13 | NULL  |
+-------+--------+---------+------+------------+-------+

Obige Abfrage verwendet den Operator AND (logisches Und). Es gibt analog auch einen Operator OR (logisches Oder):

mysql> SELECT * FROM pet WHERE species = 'snake' OR species = 'bird';
+----------+-------+---------+------+------------+-------+
| name     | owner | species | sex  | birth      | death |
+----------+-------+---------+------+------------+-------+
| Chirpy   | Gwen  | bird    | f    | 1998-09-11 | NULL  |
| Whistler | Gwen  | bird    | NULL | 1997-12-09 | NULL  |
| Slim     | Benny | snake   | m    | 1996-04-29 | NULL  |
+----------+-------+---------+------+------------+-------+

AND und OR können auch gemischt verwendet werden, wobei AND jedoch Vorrang vor OR hat. Wenn Sie beide Operatoren verwenden, bietet sich die Verwendung von Klammern an, um exakt anzugeben, wie die Bedingungen gruppiert werden sollen:

mysql> SELECT * FROM pet WHERE (species = 'cat' AND sex = 'm')
    -> OR (species = 'dog' AND sex = 'f');
+-------+--------+---------+------+------------+-------+
| name  | owner  | species | sex  | birth      | death |
+-------+--------+---------+------+------------+-------+
| Claws | Gwen   | cat     | m    | 1994-03-17 | NULL  |
| Buffy | Harold | dog     | f    | 1989-05-13 | NULL  |
+-------+--------+---------+------+------------+-------+

Wenn Sie nicht die gesamten Datensätze aus Ihrer Tabelle sehen wollen, dann führen Sie in der jeweiligen Abfrage die gewünschten Spalten durch Kommata getrennt auf. Wollen Sie also etwa wissen, wann Ihre Tiere geboren wurden, dann wählen Sie die Spalten name und geburtstag:

mysql> SELECT name, birth FROM pet;
+----------+------------+
| name     | birth      |
+----------+------------+
| Fluffy   | 1993-02-04 |
| Claws    | 1994-03-17 |
| Buffy    | 1989-05-13 |
| Fang     | 1990-08-27 |
| Bowser   | 1989-08-31 |
| Chirpy   | 1998-09-11 |
| Whistler | 1997-12-09 |
| Slim     | 1996-04-29 |
| Puffball | 1999-03-30 |
+----------+------------+

Um herauszufinden, wem welches Tier gehört, setzen Sie folgende Abfrage ab:

mysql> SELECT owner FROM pet;
+--------+
| owner  |
+--------+
| Harold |
| Gwen   |
| Harold |
| Benny  |
| Diane  |
| Gwen   |
| Gwen   |
| Benny  |
| Diane  |
+--------+

Beachten Sie, dass diese einfache Abfrage die Spalte besitzer jedes Datensatzes abruft; einige davon tauchen mehrfach auf. Um die Ausgabe zu optimieren, können Sie jeden eindeutigen Ergebnisdatensatz genau einmal ausgeben, indem Sie einfach das Schlüsselwort DISTINCT hinzufügen:

mysql> SELECT DISTINCT owner FROM pet;
+--------+
| owner  |
+--------+
| Benny  |
| Diane  |
| Gwen   |
| Harold |
+--------+

Mithilfe einer WHERE-Klausel können Sie Datensatz- und Spaltenauswahl kombinieren. Um z. B. die Geburtsdaten von Hunden und Katzen anzuzeigen, verwenden Sie folgende Abfrage:

mysql> SELECT name, species, birth FROM pet
    -> WHERE species = 'dog' OR species = 'cat';
+--------+---------+------------+
| name   | species | birth      |
+--------+---------+------------+
| Fluffy | cat     | 1993-02-04 |
| Claws  | cat     | 1994-03-17 |
| Buffy  | dog     | 1989-05-13 |
| Fang   | dog     | 1990-08-27 |
| Bowser | dog     | 1989-08-31 |
+--------+---------+------------+

Sie haben in den vorangegangenen Beispielen vielleicht bereits festgestellt, dass die Ergebnisdatensätze nicht in einer bestimmten Reihenfolge angezeigt werden. Häufig ist es jedoch einfacher, das Abfrageergebnis zu durchsuchen, wenn die Datensätze sinnvoll sortiert werden. Um ein Ergebnis zu sortieren, verwenden Sie die ORDER BY-Klausel.

Nachfolgend sind die Geburtstage der Tiere nach Datum sortiert aufgelistet:

mysql> SELECT name, birth FROM pet ORDER BY birth;
+----------+------------+
| name     | birth      |
+----------+------------+
| Buffy    | 1989-05-13 |
| Bowser   | 1989-08-31 |
| Fang     | 1990-08-27 |
| Fluffy   | 1993-02-04 |
| Claws    | 1994-03-17 |
| Slim     | 1996-04-29 |
| Whistler | 1997-12-09 |
| Chirpy   | 1998-09-11 |
| Puffball | 1999-03-30 |
+----------+------------+

Bei zeichenbasierten Spalten erfolgt die Sortierung – wie bei allen anderen Vergleichsoperationen auch – normalerweise ohne Berücksichtigung der Groß-/Kleinschreibung. Das bedeutet, dass die Reihenfolge bei Spalten, die bis auf die Groß-/Kleinschreibung identisch sind, nicht definiert ist. Sie können ein schreibweisenabhängiges Sortieren für eine Spalte erzwingen, indem Sie BINARY so verwenden: ORDER BY BINARY col_name.

Die Standardreihenfolge bei der Sortierung ist aufsteigend, d. h., die kleinsten Werte werden zuerst aufgeführt. Um in umgekehrter (absteigender) Reihenfolge zu sortieren, fügen Sie das Schlüsselwort DESC zum Namen der Spalte zu, nach der die Sortierung erfolgt:

mysql> SELECT name, birth FROM pet ORDER BY birth DESC;
+----------+------------+
| name     | birth      |
+----------+------------+
| Puffball | 1999-03-30 |
| Chirpy   | 1998-09-11 |
| Whistler | 1997-12-09 |
| Slim     | 1996-04-29 |
| Claws    | 1994-03-17 |
| Fluffy   | 1993-02-04 |
| Fang     | 1990-08-27 |
| Bowser   | 1989-08-31 |
| Buffy    | 1989-05-13 |
+----------+------------+

Sie können auch nach mehreren Spalten und diese jeweils mit eigener Reihenfolge sortieren. Um beispielsweise nach der Tierart in aufsteigender, dann dem Geburtsdatum innerhalb der Tierart in absteigender Reihenfolge (d. h. das jüngste Tier zuerst nennend) zu sortieren, verwenden Sie die folgende Abfrage:

mysql> SELECT name, species, birth FROM pet
    -> ORDER BY species, birth DESC;
+----------+---------+------------+
| name     | species | birth      |
+----------+---------+------------+
| Chirpy   | bird    | 1998-09-11 |
| Whistler | bird    | 1997-12-09 |
| Claws    | cat     | 1994-03-17 |
| Fluffy   | cat     | 1993-02-04 |
| Fang     | dog     | 1990-08-27 |
| Bowser   | dog     | 1989-08-31 |
| Buffy    | dog     | 1989-05-13 |
| Puffball | hamster | 1999-03-30 |
| Slim     | snake   | 1996-04-29 |
+----------+---------+------------+

Das Schlüsselwort DESC gilt nur für den Spaltennamen, dem es direkt vorangestellt ist (geburtstag); die Sortierreihenfolge der Spalte gattung wird hiervon nicht berührt.

MySQL bietet eine Anzahl von Funktionen, mit denen Sie datumsbezogene Berechnungen durchführen können, um etwa Altersangaben zu ermitteln oder Teile aus Datumsangaben zu extrahieren.

Um zu bestimmen, wie alt Ihre Haustiere jeweils sind, berechnen Sie die Differenz im Jahresbestandteil des aktuellen und des Geburtsdatums und ziehen den Wert 1 ab, sofern das aktuelle Datum im Kalenderjahr vor dem Geburtsdatum liegt. Die folgende Abfrage zeigt für jedes Haustier das Geburtsdatum, das aktuelle Datum und das Alter in Jahren an.

mysql> SELECT name, birth, CURDATE(),
    -> (YEAR(CURDATE())-YEAR(birth))
    -> - (RIGHT(CURDATE(),5)<RIGHT(birth,5))
    -> AS age
    -> FROM pet;
+----------+------------+------------+------+
| name     | birth      | CURDATE()  | age  |
+----------+------------+------------+------+
| Fluffy   | 1993-02-04 | 2003-08-19 |   10 |
| Claws    | 1994-03-17 | 2003-08-19 |    9 |
| Buffy    | 1989-05-13 | 2003-08-19 |   14 |
| Fang     | 1990-08-27 | 2003-08-19 |   12 |
| Bowser   | 1989-08-31 | 2003-08-19 |   13 |
| Chirpy   | 1998-09-11 | 2003-08-19 |    4 |
| Whistler | 1997-12-09 | 2003-08-19 |    5 |
| Slim     | 1996-04-29 | 2003-08-19 |    7 |
| Puffball | 1999-03-30 | 2003-08-19 |    4 |
+----------+------------+------------+------+

Hierbei extrahiert YEAR() die Jahreszahl aus dem Datum, während mit RIGHT() die fünf Zeichen ganz rechts im Datum (MM-DD, also der Monat und der Tag) ermittelt werden. Der Teil des Ausdrucks, der die Werte MM-DD vergleicht, ist entweder 1 oder 0. Hiermit wird von der Jahresdifferenz ggf. ein Jahr abgezogen, sofern CURDATE() (das aktuelle Datum) im Kalenderjahr vor geburtstag liegt. Der gesamte Ausdruck wirkt ein wenig unübersichtlich, weswegen ein Alias (tieralter) verwendet wird, um die Beschriftung der Ausgabespalte sinnvoller zu gestalten.

Die Abfrage funktioniert zwar, aber das Ergebnis ließe sich einfacher erfassen, wenn die Datensätze in einer bestimmten Reihenfolge angezeigt würden. Dies ist durch Ergänzen der Klausel ORDER BY name möglich, die die Ausgaben dem Namen nach sortiert:

mysql> SELECT name, birth, CURDATE(),
    -> (YEAR(CURDATE())-YEAR(birth))
    -> - (RIGHT(CURDATE(),5)<RIGHT(birth,5))
    -> AS age
    -> FROM pet ORDER BY name;
+----------+------------+------------+------+
| name     | birth      | CURDATE()  | age  |
+----------+------------+------------+------+
| Bowser   | 1989-08-31 | 2003-08-19 |   13 |
| Buffy    | 1989-05-13 | 2003-08-19 |   14 |
| Chirpy   | 1998-09-11 | 2003-08-19 |    4 |
| Claws    | 1994-03-17 | 2003-08-19 |    9 |
| Fang     | 1990-08-27 | 2003-08-19 |   12 |
| Fluffy   | 1993-02-04 | 2003-08-19 |   10 |
| Puffball | 1999-03-30 | 2003-08-19 |    4 |
| Slim     | 1996-04-29 | 2003-08-19 |    7 |
| Whistler | 1997-12-09 | 2003-08-19 |    5 |
+----------+------------+------------+------+

Um die Ausgabe nach dem Alter statt dem Namen zu sortieren, verwenden Sie einfach eine andere ORDER BY-Klausel:

mysql> SELECT name, birth, CURDATE(),
    -> (YEAR(CURDATE())-YEAR(birth))
    -> - (RIGHT(CURDATE(),5)<RIGHT(birth,5))
    -> AS age
    -> FROM pet ORDER BY age;
+----------+------------+------------+------+
| name     | birth      | CURDATE()  | age  |
+----------+------------+------------+------+
| Chirpy   | 1998-09-11 | 2003-08-19 |    4 |
| Puffball | 1999-03-30 | 2003-08-19 |    4 |
| Whistler | 1997-12-09 | 2003-08-19 |    5 |
| Slim     | 1996-04-29 | 2003-08-19 |    7 |
| Claws    | 1994-03-17 | 2003-08-19 |    9 |
| Fluffy   | 1993-02-04 | 2003-08-19 |   10 |
| Fang     | 1990-08-27 | 2003-08-19 |   12 |
| Bowser   | 1989-08-31 | 2003-08-19 |   13 |
| Buffy    | 1989-05-13 | 2003-08-19 |   14 |
+----------+------------+------------+------+

Eine ähnliche Abfrage kann verwendet werden, um das erreichte Alter bereits verstorbener Tiere zu bestimmen. Welche Tiere dies sind, ermitteln Sie durch die Überprüfung, ob für todestag der Wert NULL lautet. Bei denjenigen Datensätzen, bei denen der Wert nicht NULL ist, berechnen Sie die Differenz zwischen den Werten todestag und geburtstag:

mysql> SELECT name, birth, death,
    -> (YEAR(death)-YEAR(birth)) - (RIGHT(death,5)<RIGHT(birth,5))
    -> AS age
    -> FROM pet WHERE death IS NOT NULL ORDER BY age;
+--------+------------+------------+------+
| name   | birth      | death      | age  |
+--------+------------+------------+------+
| Bowser | 1989-08-31 | 1995-07-29 |    5 |
+--------+------------+------------+------+

Die Abfrage verwendet todestag IS NOT NULL statt todestag <> NULL, da NULL ein Sonderwert ist, der nicht mithilfe der üblichen Vergleichsoperatoren verglichen werden kann. Wir werden später noch darauf eingehen. Siehe auch Abschnitt 1.3.4.6, „Arbeiten mit NULL-Werten“.

Was aber, wenn Sie nun wissen wollen, welche Tiere im nächsten Monat Geburtstag haben? Für diese Art der Berechnung sind Jahr und Tag irrelevant: Sie müssen lediglich den Monat aus der Spalte geburtstag extrahieren. MySQL bietet mehrere Funktionen zur Extraktion von Datumsbestandteilen, z. B. YEAR(), MONTH() und DAYOFMONTH(). MONTH() ist für unsere Belange die passende Funktion. Um zu sehen, wie sie funktioniert, führen Sie eine einfache Abfrage aus, die den Wert von geburtstag und MONTH(geburtstag) anzeigt:

mysql> SELECT name, birth, MONTH(birth) FROM pet;
+----------+------------+--------------+
| name     | birth      | MONTH(birth) |
+----------+------------+--------------+
| Fluffy   | 1993-02-04 |            2 |
| Claws    | 1994-03-17 |            3 |
| Buffy    | 1989-05-13 |            5 |
| Fang     | 1990-08-27 |            8 |
| Bowser   | 1989-08-31 |            8 |
| Chirpy   | 1998-09-11 |            9 |
| Whistler | 1997-12-09 |           12 |
| Slim     | 1996-04-29 |            4 |
| Puffball | 1999-03-30 |            3 |
+----------+------------+--------------+

Das Suchen von Tieren, die nächsten Monat Geburtstag haben, ist ebenfalls ganz einfach. Nehmen wir einmal an, es wäre April. In diesem Fall ist der Monatswert 4 – Sie suchen also nach Tieren, die im Mai (d. h. im Monat 5) geboren sind. Das geht wie folgt:

mysql> SELECT name, birth FROM pet WHERE MONTH(birth) = 5;
+-------+------------+
| name  | birth      |
+-------+------------+
| Buffy | 1989-05-13 |
+-------+------------+

Wenn der aktuelle Monat Dezember ist, gibt es eine kleine Komplikation. Sie können nämlich nicht einfach die Monatsnummer (12) um den Wert 1 erhöhen – die Suche nach im Monat 13 geborenen Tieren brächte kein Ergebnis, weil es diesen Monat nicht gibt. Schließlich suchen Sie nach Tieren, die im Januar (Monat 1) geboren sind.

Sie können die Abfrage so verfassen, dass sie unabhängig vom aktuellen Monat funktioniert, sodass Sie die Nummer eines bestimmten Monats gar nicht verwenden müssen. DATE_ADD() erlaubt Ihnen das Addieren eines bestimmten Zeitintervalls für ein gegebenes Datum. Wenn Sie einen Monat zum aktuellen Wert von CURDATE() hinzuaddieren wollen, extrahieren Sie den Monatsbestandteil mit MONTH(). Das Ergebnis ist der Monat, in dem Sie nach Geburtstagen suchen müssen:

mysql> SELECT name, birth FROM pet
    -> WHERE MONTH(birth) = MONTH(DATE_ADD(CURDATE(),INTERVAL 1 MONTH));

Eine andere Möglichkeit, diese Aufgabe zu lösen, besteht darin, 1 hinzuzuaddieren und dann den auf den aktuellen Monat folgenden Monat zu ermitteln, wobei mithilfe der Modulofunktion (MOD) der Monatswert auf 0 gesetzt wird, wenn er derzeit 12 beträgt:

mysql> SELECT name, birth FROM pet
    -> WHERE MONTH(birth) = MOD(MONTH(CURDATE()), 12) + 1;

MONTH() gibt eine Zahl zwischen 1 und 12 zurück. Ferner gibt MOD(something,12) eine Zahl zwischen 0 und 11 zurück. Insofern muss die Addition nach MOD() erfolgen, andernfalls würden wir von November (11) direkt zu Januar (1) springen.

Wenn Sie mit dem Wert NULL noch keine Erfahrung haben, kann Ihnen manche Überraschung bevorstehen. Vom Konzept her bezeichnet NULL einen „fehlenden unbekannten Wert“ und wird etwas anders behandelt als andere Werte. Um auf NULL zu prüfen, können Sie arithmetische Vergleichsoperatoren wie =, < oder <> nicht verwenden. Um dies zu demonstrieren, geben Sie einmal Folgendes ein:

mysql> SELECT 1 = NULL, 1 <> NULL, 1 < NULL, 1 > NULL;
+----------+-----------+----------+----------+
| 1 = NULL | 1 <> NULL | 1 < NULL | 1 > NULL |
+----------+-----------+----------+----------+
|     NULL |      NULL |     NULL |     NULL |
+----------+-----------+----------+----------+

Offensichtlich lassen sich aus diesen Vergleichen keine sinngebenden Ergebnisse ziehen. Verwenden Sie stattdessen die Operatoren IS NULL und IS NOT NULL:

mysql> SELECT 1 IS NULL, 1 IS NOT NULL;
+-----------+---------------+
| 1 IS NULL | 1 IS NOT NULL |
+-----------+---------------+
|         0 |             1 |
+-----------+---------------+

In MySQL entspricht 0 oder NULL falsch, während alles andere wahr ist. Der standardmäßig wahr entsprechende Wert aus einer booleschen Operation ist 1.

Die Sonderbehandlung für NULL ist der Grund dafür, warum im vorherigen Abschnitt die Frage, welche Tiere nicht mehr leben, mit todestag IS NOT NULL statt mit todestag <> NULL ermittelt werden musste.

Zwei NULL in einer GROUP BY-Klausel werden als gleichberechtigt betrachtet.

Wenn Sie ein ORDER BY ausführen, werden NULL-Werte zuerst präsentiert, wenn Sie ORDER BY ... ASCausführen, und zuletzt, wenn Sie ORDER BY ... DESC ausführen.

Ein häufiger Fehler beim Umgang mit NULL besteht in der Annahme, dass es nicht möglich ist, eine Null oder einen Leer-String in eine Spalte einzufügen, die als NOT NULL definiert ist. Das stimmt nicht. Dies sind in der Tat Werte, wohingegen NULL bedeutet, dass es „keinen Wert gibt“. Sie können dies sehr leicht unter Verwendung von IS [NOT] NULL, wie hier gezeigt, testen:

mysql> SELECT 0 IS NULL, 0 IS NOT NULL, '' IS NULL, '' IS NOT NULL;
+-----------+---------------+------------+----------------+
| 0 IS NULL | 0 IS NOT NULL | '' IS NULL | '' IS NOT NULL |
+-----------+---------------+------------+----------------+
|         0 |             1 |          0 |              1 |
+-----------+---------------+------------+----------------+

Es ist also durchaus möglich, eine Null oder einen Leer-String in eine NOT NULL-Spalte einzusetzen, denn diese Werte sind in der Tat NOT NULL. Siehe auch Problems with NULL Values.

MySQL ermöglicht einen Mustervergleich sowohl nach SQL-Standard als auch basierend auf erweiterten regulären Ausdrücken, wie man es von Unix-Hilfsprogrammen wie vi, grep und sed her kennt.

Beim SQL-Mustervergleich können Sie „_“ für eine Übereinstimmung mit einzelnen Zeichen sowie „%“ für eine Übereinstimmung mit einer beliebigen Anzahl von Zeichen (einschließlich 0 Zeichen) verwenden. In MySQL wird bei SQL-Mustern standardmäßig keine Unterscheidung der Groß-/Kleinschreibung vorgenommen. Einige Beispiele sind hier aufgeführt. In Verbindung mit SQL-Mustern verwenden Sie nicht = oder <>, sondern die Vergleichsoperatoren LIKE bzw. NOT LIKE.

Namen, die mit „b beginnen, finden Sie so“:

mysql> SELECT * FROM pet WHERE name LIKE 'b%';
+--------+--------+---------+------+------------+------------+
| name   | owner  | species | sex  | birth      | death      |
+--------+--------+---------+------+------------+------------+
| Buffy  | Harold | dog     | f    | 1989-05-13 | NULL       |
| Bowser | Diane  | dog     | m    | 1989-08-31 | 1995-07-29 |
+--------+--------+---------+------+------------+------------+

Namen, die auf „fy enden, finden Sie so“:

mysql> SELECT * FROM pet WHERE name LIKE '%fy';
+--------+--------+---------+------+------------+-------+
| name   | owner  | species | sex  | birth      | death |
+--------+--------+---------+------+------------+-------+
| Fluffy | Harold | cat     | f    | 1993-02-04 | NULL  |
| Buffy  | Harold | dog     | f    | 1989-05-13 | NULL  |
+--------+--------+---------+------+------------+-------+

Und Namen, die „w enthalten, finden Sie so“:

mysql> SELECT * FROM pet WHERE name LIKE '%w%';
+----------+-------+---------+------+------------+------------+
| name     | owner | species | sex  | birth      | death      |
+----------+-------+---------+------+------------+------------+
| Claws    | Gwen  | cat     | m    | 1994-03-17 | NULL       |
| Bowser   | Diane | dog     | m    | 1989-08-31 | 1995-07-29 |
| Whistler | Gwen  | bird    | NULL | 1997-12-09 | NULL       |
+----------+-------+---------+------+------------+------------+

Um Namen zu ermitteln, die aus genau fünf Zeichen bestehen, verwenden Sie fünf Instanzen des Musterzeichens „_“:

mysql> SELECT * FROM pet WHERE name LIKE '_____';
+-------+--------+---------+------+------------+-------+
| name  | owner  | species | sex  | birth      | death |
+-------+--------+---------+------+------------+-------+
| Claws | Gwen   | cat     | m    | 1994-03-17 | NULL  |
| Buffy | Harold | dog     | f    | 1989-05-13 | NULL  |
+-------+--------+---------+------+------------+-------+

Der andere von MySQL unterstützte Mustervergleichstyp nutzt erweiterte reguläre Ausdrücke. Wenn Sie bei diesem Mustertyp auf Übereinstimmung testen, verwenden Sie die Operatoren REGEXP und NOT REGEXP (bzw. deren Synonyme RLIKE und NOT RLIKE).

Die folgende Liste beschreibt einige Merkmale von erweiterten regulären Ausdrücken:

Um zu demonstrieren, wie erweiterte reguläre Ausdrücke funktionieren, haben wir die oben gezeigten LIKE-Abfragen so umgeschrieben, dass sie REGEXP verwenden.

Um Namen zu finden, die mit „b“ beginnen, verwenden Sie „^“ für eine Übereinstimmung mit dem Namensanfang:

mysql> SELECT * FROM pet WHERE name REGEXP '^b';
+--------+--------+---------+------+------------+------------+
| name   | owner  | species | sex  | birth      | death      |
+--------+--------+---------+------+------------+------------+
| Buffy  | Harold | dog     | f    | 1989-05-13 | NULL       |
| Bowser | Diane  | dog     | m    | 1989-08-31 | 1995-07-29 |
+--------+--------+---------+------+------------+------------+

Wenn Sie einen REGEXP-Vergleich mit Unterscheidung der Groß-/Kleinschreibung wirklich erzwingen wollen, verwenden Sie das Schlüsselwort BINARY, um aus einem der Strings einen Binär-String zu machen. Bei folgender Abfrage liegt eine Übereinstimmung nur bei einem kleinen „b am Anfang des Namens vor:“

mysql> SELECT * FROM pet WHERE name REGEXP BINARY '^b';

Um Namen zu finden, die auf „fy“ enden, verwenden Sie „$“ für eine Übereinstimmung mit dem Namensende:

mysql> SELECT * FROM pet WHERE name REGEXP 'fy$';
+--------+--------+---------+------+------------+-------+
| name   | owner  | species | sex  | birth      | death |
+--------+--------+---------+------+------------+-------+
| Fluffy | Harold | cat     | f    | 1993-02-04 | NULL  |
| Buffy  | Harold | dog     | f    | 1989-05-13 | NULL  |
+--------+--------+---------+------+------------+-------+

Namen schließlich, die „w“ enthalten, finden Sie mit folgender Abfrage:

mysql> SELECT * FROM pet WHERE name REGEXP 'w';
+----------+-------+---------+------+------------+------------+
| name     | owner | species | sex  | birth      | death      |
+----------+-------+---------+------+------------+------------+
| Claws    | Gwen  | cat     | m    | 1994-03-17 | NULL       |
| Bowser   | Diane | dog     | m    | 1989-08-31 | 1995-07-29 |
| Whistler | Gwen  | bird    | NULL | 1997-12-09 | NULL       |
+----------+-------+---------+------+------------+------------+

Da ein auf einem regulären Ausdruck basierendes Muster eine Übereinstimmung liefert, wenn es an beliebiger Stelle im Wert auftaucht, ist es in dieser Abfrage nicht notwendig, ein Jokerzeichen an den beiden Seiten des Musters zu setzen (bei einem SQL-Muster wäre dies hingegen erforderlich, um eine Übereinstimmung zu erzielen).

Um Namen zu ermitteln, die aus genau fünf Zeichen bestehen, verwenden Sie „^“ und „$“ für Übereinstimmungen für Anfang und Ende des Namens und fünf Instanzen von „.“ dazwischen:

mysql> SELECT * FROM pet WHERE name REGEXP '^.....$';
+-------+--------+---------+------+------------+-------+
| name  | owner  | species | sex  | birth      | death |
+-------+--------+---------+------+------------+-------+
| Claws | Gwen   | cat     | m    | 1994-03-17 | NULL  |
| Buffy | Harold | dog     | f    | 1989-05-13 | NULL  |
+-------+--------+---------+------+------------+-------+

Sie könnten diese Abfrage auch mithilfe des Operators {n} („n-mal wiederholen“) schreiben:

mysql> SELECT * FROM pet WHERE name REGEXP '^.{5}$';
+-------+--------+---------+------+------------+-------+
| name  | owner  | species | sex  | birth      | death |
+-------+--------+---------+------+------------+-------+
| Claws | Gwen   | cat     | m    | 1994-03-17 | NULL  |
| Buffy | Harold | dog     | f    | 1989-05-13 | NULL  |
+-------+--------+---------+------+------------+-------+

In Abschnitt 7.4.2, „Reguläre Ausdrücke“, finden Sie weitere Informationen zur Syntax regulärer Ausdrücke.

Datenbanken werden oft verwendet, um die Frage zu beantworten, „wie oft eine gewisse Art von Daten in einer Tabelle auftritt“.Sie könnten zum Beispiel wissen wollen, wieviele Haustiere Sie haben oder wieviele Haustiere jeder Besitzer hat, oder Sie könnten verschiedene Arten von statistischen Daten zu Ihren Tieren erheben wollen.

Das Zählen aller vorhandenen Tiere entspricht der Frage „Wie viele Datensätze sind in der Tabelle haustier vorhanden?“, denn es gibt genau einen Datensatz pro Tier. COUNT(*) zählt die Anzahl der Datensätze, d. h., die Abfrage zur Zählung Ihrer Tiere sieht wie folgt aus:

mysql> SELECT COUNT(*) FROM pet;
+----------+
| COUNT(*) |
+----------+
|        9 |
+----------+

Weiter oben haben Sie die Namen der Leute abgerufen, die Tiere besitzen. Mit COUNT() können Sie etwa ermitteln, wie viele Tiere jeder Besitzer hat:

mysql> SELECT owner, COUNT(*) FROM pet GROUP BY owner;
+--------+----------+
| owner  | COUNT(*) |
+--------+----------+
| Benny  |        2 |
| Diane  |        2 |
| Gwen   |        3 |
| Harold |        2 |
+--------+----------+

Die vorangehende Abfrage nutzt GROUP BY, um alle Datensätze für jeden Besitzer zu gruppieren. Die Kombination von COUNT() mit GROUP BY ist nützlich für die Charakterisierung Ihrer Daten in verschiedenen Einteilungen. Die folgenden Beispiele zeigen verschiedene Wege, statistische Daten zu den Tieren zu erheben.

Anzahl der Exemplare je Tierart:

mysql> SELECT species, COUNT(*) FROM pet GROUP BY species;
+---------+----------+
| species | COUNT(*) |
+---------+----------+
| bird    |        2 |
| cat     |        2 |
| dog     |        3 |
| hamster |        1 |
| snake   |        1 |
+---------+----------+

Anzahl der Tiere je Geschlecht:

mysql> SELECT sex, COUNT(*) FROM pet GROUP BY sex;
+------+----------+
| sex  | COUNT(*) |
+------+----------+
| NULL |        1 |
| f    |        4 |
| m    |        4 |
+------+----------+

(In dieser Ausgabe gibt NULL an, dass das Geschlecht unbekannt ist.)

Anzahl der Tiere je Kombination von Tierart und Geschlecht:

mysql> SELECT species, sex, COUNT(*) FROM pet GROUP BY species, sex;
+---------+------+----------+
| species | sex  | COUNT(*) |
+---------+------+----------+
| bird    | NULL |        1 |
| bird    | f    |        1 |
| cat     | f    |        1 |
| cat     | m    |        1 |
| dog     | f    |        1 |
| dog     | m    |        2 |
| hamster | f    |        1 |
| snake   | m    |        1 |
+---------+------+----------+

Wenn Sie COUNT() verwenden, müssen Sie nicht die gesamte Tabelle abrufen. Die obige Abfrage beispielsweise sieht wie folgt aus, wenn Sie nur für Hunde und Katzen durchgeführt wird:

mysql> SELECT species, sex, COUNT(*) FROM pet
    -> WHERE species = 'dog' OR species = 'cat'
    -> GROUP BY species, sex;
+---------+------+----------+
| species | sex  | COUNT(*) |
+---------+------+----------+
| cat     | f    |        1 |
| cat     | m    |        1 |
| dog     | f    |        1 |
| dog     | m    |        2 |
+---------+------+----------+

Oder, wenn Sie die Anzahl der Tiere je Geschlecht nur für diejenigen Tiere anzeigen wollen, deren Geschlecht auch bekannt ist:

mysql> SELECT species, sex, COUNT(*) FROM pet
    -> WHERE sex IS NOT NULL
    -> GROUP BY species, sex;
+---------+------+----------+
| species | sex  | COUNT(*) |
+---------+------+----------+
| bird    | f    |        1 |
| cat     | f    |        1 |
| cat     | m    |        1 |
| dog     | f    |        1 |
| dog     | m    |        2 |
| hamster | f    |        1 |
| snake   | m    |        1 |
+---------+------+----------+

Wenn Sie Spalten zusätzlich zum COUNT()-Wert, zur Auswahl benennen, sollte eine GROUP BY-Klausel vorhanden sein, die diese gleichen Spalten benennt. Ansonsten tritt das folgende Verhalten auf:

Siehe auch Abschnitt 7.12.3, „GROUP BY und HAVING mit verborgenen Spalten“.

Die Tabelle haustier enthält Daten zu den Tieren, die Sie besitzen. Wollen Sie andere Informationen zu diesen aufzeichnen – z. B. Ereignisse wie Tierarztbesuche oder die Ankunft von Nachwuchs –, dann benötigen Sie eine zweite Tabelle. Wie sollte diese Tabelle aussehen? Sie muss die folgenden Informationen enthalten:

Unter Berücksichtigung dieser Aspekte könnte die CREATE TABLE-Anweisung für die Tabelle ereignis wie folgt aussehen:

mysql> CREATE TABLE event (name VARCHAR(20), date DATE,
    -> type VARCHAR(15), remark VARCHAR(255));

Wie bei der Tabelle haustier ist es auch hier am einfachsten, die bereits bekannten Daten über eine tabulatorgetrennte Textdatei in die Tabelle einzuladen. Diese Datei soll die folgenden Informationen enthalten.

Laden Sie die Datensätze wie folgt:

mysql> LOAD DATA LOCAL INFILE 'event.txt' INTO TABLE event;

Mit dem, was Sie bereits aus den Abfragen erlernt haben, die Sie zur Tabelle haustier abgesetzt haben, sollten Sie auch Daten aus der Tabelle ereignis abrufen können; die Prinzipien sind dieselben. Was aber, wenn Sie die Fragen, die Sie stellen, mit der Tabelle ereignis allein nicht beantworten können?

Nehmen wir an, Sie wollen herausfinden, in welchem Alter die jeweiligen Tiere Nachwuchs bekommen haben. Wir haben bereits weiter oben gesehen, wie Sie das Alter auf der Grundlage zweiter Datumsangaben berechnen. Das Datum, an dem die Mutter ihren Nachwuchs auf die Welt gebracht hat, ist in der Tabelle ereignis gespeichert, aber um das Alter der Mutter am Tag der Niederkunft zu ermitteln, benötigen Sie das Geburtsdatum, welches wiederum in der Tabelle haustier abgelegt ist. Das bedeutet, dass wir zwei Tabellen benötigen:

mysql> SELECT pet.name,
    -> (YEAR(date)-YEAR(birth)) - (RIGHT(date,5)<RIGHT(birth,5)) AS age,
    -> remark
    -> FROM pet INNER JOIN event
    ->   ON pet.name = event.name
    -> WHERE event.type = 'litter';
+--------+------+-----------------------------+
| name   | age  | remark                      |
+--------+------+-----------------------------+
| Fluffy |    2 | 4 kittens, 3 female, 1 male |
| Buffy  |    4 | 5 puppies, 2 female, 3 male |
| Buffy  |    5 | 3 puppies, 3 female         |
+--------+------+-----------------------------+

Bei dieser Abfrage fällt Verschiedenes auf:

Um eine solche Verknüpfung – einen Join – durchzuführen, brauchen Sie keine zwei Tabellen. Manchmal ist es nützlich, eine Tabelle mit sich selbst zu verknüpfen, wenn man etwa Datensätze in einer Tabelle mit anderen Datensätzen in derselben Tabelle vergleichen will. Um beispielsweise Zuchtmöglichkeiten unter Ihren Tieren auszuloten, kann eine Verknüpfung der Tabelle haustier mit sich selbst praktisch sein, um passende Männchen und Weibchen einer Tierart zu ermitteln:

mysql> SELECT p1.name, p1.sex, p2.name, p2.sex, p1.species
    -> FROM pet AS p1 INNER JOIN pet AS p2
    ->   ON p1.species = p2.species AND p1.sex = 'f' AND p2.sex = 'm';
+--------+------+--------+------+---------+
| name   | sex  | name   | sex  | species |
+--------+------+--------+------+---------+
| Fluffy | f    | Claws  | m    | cat     |
| Buffy  | f    | Fang   | m    | dog     |
| Buffy  | f    | Bowser | m    | dog     |
+--------+------+--------+------+---------+

In dieser Abfrage geben Sie Aliase für den Tabellennamen an, um auf die Spalten Bezug zu nehmen und klar zu machen, welcher Tabelleninstanz die Bezugnahme auf eine Spalte zuzuordnen ist.

Die erste zu treffende Entscheidung ist die, ob Sie einen (stabilen) Produktions-Release oder aber einen Entwicklungs-Release verwenden wollen. Im MySQL-Entwicklungsprozess koexistieren mehrere Release-Serien miteinander, die sich alle durch ihren Grad der Ausgereiftheit voneinander unterscheiden:

Wir halten ein endgültiges Einfrieren von Codes nicht für machbar, da dies Bugfixes und andere Fehlerbereinigungen, die erforderlich sind, unmöglich machen würde. Das von uns bevorzugte „Teileinfrieren“ erlaubt uns das Ergänzen von Kleinigkeiten, die sich nicht auf die Einsatzfähigkeit eines Produktions-Releases auswirken sollten. Natürlich pflanzen sich wesentliche Bugfixes in früheren Serien auch auf ihre jeweiligen Nachfolger fort.

Wenn Sie MySQL zum ersten Mal verwenden oder es auf ein System portieren wollen, für das keine binäre Distribution verfügbar ist, verwenden Sie die General-Availability-Release-Serie. Gegenwärtig ist das MySQL 5.1. Alle MySQL-Releases – auch die der Entwicklungsserie – werden vor der Veröffentlichung mit den MySQL-Benchmarks und der umfangreichen Testsuite überprüft.

Wenn Sie ein älteres System verwenden und ein Upgrade durchführen möchten, gleichzeitig aber Probleme bei der Aktualisierung vermeiden möchten, sollten Sie auf die aktuelle Version derselben Release-Serie aktualisieren, die Sie bereits verwenden (hierbei ist nur der letzte Teil der Versionsnummer höher als bei der von Ihnen verwendeten Version). Wir haben lediglich versucht, kritische Bugs zu beheben und kleine, relativ „sichere“ Änderungen an dieser Version vorzunehmen.

Wenn Sie neue Funktionen verwenden wollen, die nicht in der Produktions-Release-Serie vorhanden sind, können Sie sich auch für eine Version aus der Entwicklungsserie entscheiden. Beachten Sie, dass die Entwicklungs-Releases nicht so stabil sind wie die Produktions-Releases.

Wollen Sie die allerneuesten Quellcodes mit allen aktuellen Patches und Bugfixes einsetzen, dann können Sie eines unserer Bazaar-Repositorys verwenden. Dies sind nicht „Releases“ im eigentlichen Sinne, sondern Vorabversionen des Codes, auf dem zukünftige Releases basieren werden.

Das MySQL-Benennungsschema verwendet Release-Namen, die aus drei Zahlen und einem Suffix bestehen. Dies kann etwa so aussehen: mysql-5.0.12-beta. Die Zahlen im Release-Namen sind wie folgt zu interpretieren:

Bei kleineren Updates wird jeweils die letzte Zahl im Versions-String hochgezählt. Liegen wesentliche Neuerungen bei den Merkmalen oder kleinere Inkompatibilitäten mit vorherigen Versionen vor, dann wird die zweite Zahl im Versions-String hochgezählt. Ändert sich schließlich das Dateiformat, dann wird die erste Zahl erhöht.

Release-Namen enthalten auch ein Suffix, welches die Stabilitätsstufe für den Release angibt. Releases innerhalb einer Serie durchschritten eine bestimmte Abfolge von Suffixen, die jeweils anzeigen, wie sich die Stabilität erhöht. Mögliche Suffixe sind die folgenden:

MySQL verwendet ein Benennungsschema, welches sich geringfügig von dem anderer Produkte unterscheidet. In der Regel können Sie problemlos jede Version einsetzen, die bereits seit ein paar Wochen verfügbar ist, ohne durch eine neue Version innerhalb derselben Release-Serie ersetzt worden zu sein.

Alle MySQL-Releases werden mit unseren Standardtests und Benchmarks überprüft, damit gewährleistet ist, dass ihr Einsatz relativ sicher ist. Da die Standardtests im Laufe der Zeit so erweitert werden, dass alle zuvor gefundenen Bugs berücksichtigt werden, wird unsere Testsuite immer besser.

Alle Releases wurden zumindest mit den folgenden Tools getestet:

Wir testen außerdem die neueste MySQL-Version immer auf zumindest einem System in unserer internen Produktionsumgebung. Dabei stehen uns mehr als 100 Gbyte Daten zum Arbeiten zur Verfügung.

Nachdem Sie die zu installierende MySQL-Version gewählt haben, müssen Sie noch festlegen, ob eine binäre oder eine Quelldistribution für die Installation verwendet werden soll. In den meisten Fällen werden Sie sich wahrscheinlich für die Binärdistribution entscheiden, sofern es für Ihre Plattform eine solche gibt. Binärdistributionen sind für viele Plattformen im nativen Format verfügbar, z. B. RPM-Dateien für Linux oder PKG-Paket-Installer für Mac OS X oder Solaris. Distributionen sind außerdem als Zip-Archive oder komprimierte tar-Dateien erhältlich.

Die folgenden Gründe sprechen für die Verwendung einer Binärdistribution:

Unter bestimmten Umständen kann es auch von Vorteil sein, MySQL aus einer Quelldistribution heraus zu installieren:

MySQL entwickelt sich ziemlich schnell, und neue Entwicklungen wollen wir anderen MySQL-Benutzern möglichst umgehend bereitstellen. Deswegen erstellen wir immer dann einen neuen Release, wenn wir neue und nützliche Funktionen integriert haben, die auch für andere Benutzer nützlich oder notwendig sein könnten.

Außerdem versuchen wir Benutzern zu helfen, die nach Funktionen fragen, welche leicht zu implementieren sind. Wir achten darauf, was unsere lizenzierten Benutzer – und insbesondere die Kunden, die unseren Support nutzen – wünschen, und versuchen, ihnen in dieser Hinsicht zu helfen.

Niemand ist gezwungen, einen neuen Release herunterzuladen. Der Abschnitt ?News“ soll Ihnen dabei helfen zu ermitteln, ob im neuen Release etwas dabei ist, was Sie wirklich brauchen. Siehe auch MySQL Change History.

Bei der Aktualisierung von MySQL halten wir uns an die folgenden Richtlinien:

Sun Microsystems, Inc. bietet verschiedene MySQL-Binärdistributionen. Neben den Binärdateien in den plattformspezifischen Paketformaten bieten wir für eine Anzahl von Plattformen auch Binärdistributionen in Form komprimierter tar-Dateien (.tar.gz-Dateien) an. Siehe auch Abschnitt 2.2, „MySQL-Standardinstallation mithilfe einer Binärdistribution“. Informationen zu Windows-Distributionen finden Sie in Abschnitt 2.3, „Installieren von MySQL unter Windows“.

Wollen Sie eine Debug-Version von MySQL aus einer Quelldistribution kompilieren, dann sollten Sie die Option --with-debug bzw. --with-debug=full an den für die Distribution verwendeten configure-Befehl anfügen und ggf. vorhandene -fomit-frame-pointer-Optionen entfernen.

Wenn Sie ein MySQL-Paket heruntergeladen haben, sollten Sie sicherstellen, dass die zugehörige MD5-Prüfsumme mit der auf den MySQL-Downloadseiten angegebenen Prüfsumme übereinstimmt. Jedes Paket weist eine individuelle Prüfsumme auf, die Sie mithilfe des folgenden Befehls abfragen können (hierbei ist package_name der Name des heruntergeladenen Pakets):

shell> md5sum package_name

Beispiel:

shell> md5sum mysql-standard-5.1.54-linux-i686.tar.gz
aaab65abbec64d5e907dcd41b8699945  mysql-standard-5.1.54-linux-i686.tar.gz

Vergewissern Sie sich, dass die resultierende Prüfsumme (der angezeigte Hexadezimal-String) mit der Angabe übereinstimmt, die auf der Downloadseite unmittelbar unter dem betreffenden Paket angegeben ist.

Beachten Sie, dass nicht alle Betriebssysteme den Befehl md5sum unterstützen. Bei manchen heißt er einfach md5, bei anderen ist er überhaupt nicht enthalten. Bei Linux ist er Teil des Pakets GNU Text Utilities, das für eine Vielzahl von Plattformen verfügbar ist. Sie können den Quellcode auch unter http://www.gnu.org/software/textutils/ herunterladen. Wenn Sie OpenSSL installiert haben, können Sie stattdessen den Befehl openssl md5 package_name verwenden. Eine Windows-Implementierung des Befehls md5 ist unter http://www.fourmilab.ch/md5/ verfügbar. winMd5Sum ist ein grafisches MD5-Prüfwerkzeug, das Sie sich unter http://www.nullriver.com/index/products/winmd5sum beschaffen können.

Eine andere Methode zur Überprüfung der Integrität und Authentizität eines Pakets besteht in der Verwendung kryptografischer Signaturen. Diese sind zuverlässiger, aber arbeitsaufwändiger als MD5-Prüfsummen.

Wir signieren die von MySQL herunterladbaren Pakete mit GnuPG (GNU Privacy Guard). GnuPG ist eine Open-Source-Alternative zum bekannten Pretty Good Privacy (PGP) von Phil Zimmermann. Weitere Informationen zu GnuPG sowie zu dessen Download und Installation auf Ihrem System finden Sie unter http://www.gnupg.org/. Die meisten Linux-Distributionen werden mit standardmäßig installiertem GnuPG ausgeliefert. Weitere Informationen zu GnuPG finden Sie unter http://www.openpgp.org/.

Um die Signatur für ein bestimmtes Paket zu überprüfen, müssen Sie sich zunächst eine Kopie unseres GPG-Build-Schlüssels beschaffen. Diese können Sie unter http://keyserver.pgp.com/ herunterladen. Der erforderliche Schlüssel heißt build@mysql.com. Alternativ können Sie den Schlüssel aus dem folgenden Text kopieren und direkt einfügen:

-----BEGIN PGP PUBLIC KEY BLOCK-----
Version: GnuPG v1.0.6 (GNU/Linux)
Comment: For info see http://www.gnupg.org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=Xquv
-----END PGP PUBLIC KEY BLOCK-----

Um den Schlüssel in Ihren eigenen öffentlichen GPG-Schlüsselbund zu importieren, verwenden Sie gpg --import. Haben Sie den Schlüssel beispielsweise unter dem Dateinamen mysql_pubkey.asc gespeichert, dann sieht der Importbefehl wie folgt aus:

shell> gpg --import mysql_pubkey.asc
gpg: key 5072E1F5: public key "MySQL Package signing key (www.mysql.com) <build@mysql.com>" imported
gpg: Total number processed: 1
gpg:               imported: 1
gpg: no ultimately trusted keys found

Alternativ können Sie den Schlüssel vom öffentlichen Schlüsselserver mit der öffentlichen Schlüsselkennung 5072E1F5 herunterladen:

shell> gpg --recv-keys 5072E1F5
gpg: requesting key 5072E1F5 from hkp server subkeys.pgp.net
gpg: key 5072E1F5: "MySQL Package signing key (www.mysql.com) <build@mysql.com>" 2 new signatures
gpg: no ultimately trusted keys found
gpg: Total number processed: 1
gpg:         new signatures: 2

Wenn Sie den Schlüssel zur Bestätigung von RPM-Installationspaketen in Ihre RPM-Konfiguration importieren wollen, sollten Sie den Schlüssel direkt importieren können:

shell> rpm --import mysql_pubkey.asc

Bei Problemen versuchen Sie, den Schlüssel von gpg zu exportieren und zu importieren:

shell> gpg --export -a 5072e1f5 > 5072e1f5.asc
shell> rpm --import 5072e1f5.asc

Alternativ unterstützt rpm auch das direkte Laden des Schlüssels von einer URL. Dafür können Sie diese Handbuchseite verwenden:

shell> rpm --import http://dev.mysql.com/doc/refman/5.1/en/checking-gpg-signature.html

Nachdem Sie den öffentlichen Schlüssel heruntergeladen und importiert haben, laden Sie das gewünschte MySQL-Paket und die entsprechende Signatur herunter (diese steht ebenfalls auf der Downloadseite zur Verfügung). Die Signaturdatei hat den gleichen Namen wie die Distributionsdatei und trägt die Erweiterung .asc (siehe Beispiele in der folgenden Tabelle).

Stellen Sie sicher, dass beide Dateien im gleichen Verzeichnis gespeichert sind, und führen Sie dann den folgenden Befehl aus, um die Signatur der Distributionsdatei zu verifizieren:

shell> gpg --verify package_name.asc

Beispiel:

shell> gpg --verify mysql-standard-5.1.54-linux-i686.tar.gz.asc
gpg: Signature made Tue 12 Jul 2005 23:35:41 EST using DSA key ID 5072E1F5
gpg: Good signature from "MySQL Package signing key (www.mysql.com) <build@mysql.com>"

Die Meldung Good signature (Signatur korrekt) zeigt an, dass alles in Ordnung ist. Sie können alle Warnungen vom Typ insecure memory ignorieren, die unter Umständen angezeigt werden.

Weitere Informationen zum Umgang mit öffentlichen Schlüsseln finden Sie in der GPG-Dokumentation.

Bei RPM-Paketen ist keine separate Signatur vorhanden. RPM-Pakete enthalten vielmehr eine integrierte GPG-Signatur und eine MD5-Prüfsumme. Sie können ein Paket durch Ausführen des folgenden Befehls verifizieren:

shell> rpm --checksig package_name.rpm

Beispiel:

shell> rpm --checksig MySQL-server-5.1.54-0.glibc23.i386.rpm
MySQL-server-5.1.54-0.glibc23.i386.rpm: md5 gpg OK

shell> rpm --import mysql_pubkey.asc

Wie Sie sich den öffentlichen MySQL-Schlüssel beschaffen, lesen Sie in Abschnitt 2.1.4.2, „Signaturüberprüfung mit GnuPG“.

Die MySQL-Installationspakete können unter http://dev.mysql.com/downloads/ heruntergeladen werden. Wenn das von Ihnen heruntergeladene Paket in einem ZIP-Archiv gespeichert ist, müssen Sie dieses zunächst entpacken.

Der Vorgang zum Starten des Assistenten hängt vom Inhalt des heruntergeladenen Installationspakets ab. Enthält dieses eine Datei namens setup.exe, dann doppelklicken Sie darauf, um den Installationsvorgang zu starten. Enthält das Paket eine .msi-Datei, dann doppelklicken Sie darauf, um den Installationsvorgang zu starten.

Es gibt drei verfügbare Installationstypen: Typical (Standard), Complete (Vollständig) und Custom (Benutzerdefiniert).

Bei der Installationsmethode Typical werden der MySQL Server, der Befehlszeilenclient mysql und die befehlszeilenbasierten Hilfsprogramme installiert. Zu den Befehlszeilenclients und Hilfsprogrammen gehören mysqldump, myisamchk und verschiedene weitere Programme zur Verwaltung des MySQL Servers.

Die Installationsmethode Complete installiert alle Komponenten, die im Installationspaket enthalten sind. Das vollständige Installationspaket umfasst Komponenten wie die eingebettete Serverbibliothek, die Benchmark-Reihe, Support-Skripten und die Dokumentation.

Bei der Installationsmethode Custom haben Sie vollständige Kontrolle darüber, welche Pakete installiert werden und wie der Installationspfad aussieht. Weitere Informationen zur benutzerdefinierten Installation finden Sie unter Abschnitt 2.3.3.3, „Der Dialog zur benutzerspezifischen Installation“.

Wenn Sie sich für die Installationsmethode Typical oder Complete entschieden haben und auf die Schaltfläche Next klicken, wird ein Fenster angezeigt, in dem Sie die gewählten Optionen überprüfen und die Installation dann starten können. Wenn Sie hingegen die Methode Custom auswählen und dann auf die Schaltfläche Next klicken, wird nachfolgend das Dialogfeld für die benutzerdefinierte Installation aufgerufen, welches in Abschnitt 2.3.3.3, „Der Dialog zur benutzerspezifischen Installation“, beschrieben wird.

Wenn Sie den Installationspfad oder bestimmte Komponenten ändern wollen, die vom MySQL-Installations-Assistenten installiert werden, wählen Sie die Installationsmethode Custom.

Alle verfügbaren Komponenten werden dann in einer Baumstruktur links im Installationsdialog angezeigt. Komponenten, die nicht installiert werden, sind durch ein rotes X gekennzeichnet, während für die Installation gewählten Komponenten ein graues Symbol aufweisen. Um den Installationsstatus einer Komponente umzuschalten, klicken Sie auf das Symbol der betreffenden Komponente und wählen die gewünschte Option aus der erscheinenden Dropdown-Liste.

Sie können den vorgegebenen Installationspfad ändern, indem Sie auf die Schaltfläche Change... rechts neben dem angezeigten Installationspfad klicken.

Wenn Sie die zu installierenden Komponenten und den Pfad gewählt haben, klicken Sie auf die Schaltfläche Next, um den Bestätigungsdialog anzuzeigen.

Wenn Sie eine Installationsmethode und ggf. die zu installierenden Komponenten gewählt haben, schreiten Sie fort zum Bestätigungsdialog. Installationsmethode und Pfad werden nun zur Bestätigung angezeigt.

Wenn die angezeigten Einstellungen korrekt sind, klicken Sie auf die Schaltfläche Install, um MySQL zu installieren. Wenn Sie Ihre Einstellungen noch einmal ändern wollen, klicken Sie auf die Schaltfläche Back. Um den MySQL-Installations-Assistenten zu verlassen, ohne MySQL zu installieren, klicken Sie auf die Schaltfläche Cancel.

Wenn die Installation abgeschlossen ist, können Sie sich auf der MySQL-Website registrieren. Wenn Sie registriert sind, können Sie Mitteilungen an die MySQL-Foren unter forums.mysql.com schicken, Bugs unter bugs.mysql.com melden und unseren Newsletter abonnieren. Der Abschlussbildschirm des Installationsprogramms zeigt eine Zusammenfassung der Installation und erlaubt Ihnen den Aufruf des MySQL-Konfigurations-Assistenten, mit dem Sie eine Konfigurationsdatei erstellen, den MySQL-Dienst installieren und die Sicherheitseinstellungen konfigurieren können.

Wenn Sie auf die Schaltfläche Install klicken, startet der MySQL-Installations-Assistent den Installationsvorgang und nimmt bestimmte Änderungen an Ihrem System vor, die in den nachfolgenden Abschnitten beschrieben sind.

Änderungen in der Registrierung

Der MySQL-Installations-Assistent erstellt bei Auswahl der Standardinstallation einen Schlüssel in der Windows-Registrierung. Dieser befindet sich unter HKEY_LOCAL_MACHINE\SOFTWARE\MySQL AB.

Der MySQL-Installations-Assistent richtet einen Schlüssel ein, der nach der Hauptversion des installierten Servers benannt ist (z. B. MySQL Server 5.1). Dieser enthält zwei Zeichenfolgenwerte namens Location und Version. Die Zeichenfolge Location enthält den Pfad zum Installationsverzeichnis. Bei einer Standardinstallation heißt der Wert C:\Program Files\MySQL\MySQL Server 5.1\. Die Zeichenfolge Version enthält die Release-Nummer. Wird etwa MySQL Server 5.1.54 installiert, dann erhält der Schlüssel den Wert 5.1.54.

Diese Registrierungsschlüssel ermöglichen es externen Programmen, das Installationsverzeichnis des MySQL Servers zu ermitteln; hierdurch wird eine zeitaufwändige vollständige Durchsuchung der Festplatte zur Ermittlung des Installationspfads des MySQL Servers unnötig. Die Registrierungsschlüssel sind für die Ausführung des Servers nicht erforderlich und werden, wenn Sie MySQL aus dem Noinstall-Archiv installieren, auch nicht erstellt.

Änderungen im Startmenü

Der MySQL-Installations-Assistent erstellt im Windows-Menü Start einen neuen Eintrag in einem MySQL-Menü, welches nach der installierten MySQL-Hauptversion benannt ist. Installieren Sie beispielsweise MySQL 5.1, dann erstellt der Installations-Assistent einen Abschnitt namens MySQL Server 5.1 im Menü Start.

In diesem neuen Abschnitt im Menü Start werden die folgenden Einträge eingerichtet:

Änderungen am Dateisystem

Der MySQL-Installations-Assistent installiert den MySQL 5.1 Server standardmäßig im Verzeichnis C:\Program Files\MySQL\MySQL Server 5.1. Hierbei ist Program Files das Standardverzeichnis für Anwendungen auf Ihrem System und 5.1 die Hauptversion Ihres MySQL Servers. Dies ist das empfohlene Verzeichnis für den MySQL Server. Es ersetzt die vormalige Standardposition C:\mysql.

Standardmäßig werden alle MySQL-Anwendungen in einem gemeinsamen Verzeichnis in C:\Program Files\MySQL gespeichert. Hierbei ist Program Files in Ihrer Windows-Installation das Standardverzeichnis für Anwendungen. Bei einer typischen MySQL-Installation auf einem Entwicklersystem könnte dies wie folgt aussehen:

C:\Program Files\MySQL\MySQL Server 5.1
C:\Program Files\MySQL\MySQL Workbench 5.1 OSS

Dieser Ansatz erleichtert Verwaltung und Pflege aller auf einem System installierten MySQL-Anwendungen.

In MySQL 5.1.23 und früher befindet sich der Standard-Speicherort für die von MySQL verwendeten Datendateien im entsprechenden MySQL Server-Installationsverzeichnis. In MySQL 5.1.24 und später ist der Standard-Speicherort des Datenverzeichnisses das Verzeichnis AppData, das für den Benutzer konfiguriert wird, der die MySQL-Anwendung installiert hat.

Der MySQL-Installations-Assistent kann Server-Upgrades automatisch mithilfe der MSI-Aktualisierungsfunktionen durchführen. Das bedeutet, dass Sie eine vorhandene Installation nicht mehr manuell entfernen müssen, bevor Sie einen neuen Release installieren. Das Installationsprogramm beendet und entfernt den vorhandenen MySQL-Dienst selbsttätig, bevor die neue Version installiert wird.

Automatische Upgrades sind nur dann verfügbar, wenn Sie Aktualisierungen zwischen Installationen durchführen, die die gleiche Haupt- und Unterversionsnummern aufweisen. So kann etwa ein automatisches Upgrade von MySQL 4.1.5 auf MySQL 4.1.6 erfolgen, nicht jedoch von MySQL 5.0 auf MySQL 5.1.

Siehe auch Abschnitt 2.3.14, „Aktualisieren von MySQL unter Windows“.

Der MySQL Server-Konfigurations-Assistent wird normalerweise im Rahmen des Installationsprozesses gestartet. Sie sollten den MySQL Server-Konfigurations-Assistenten nur dann erneut ausführen müssen, wenn Sie die Konfigurationsparameter Ihres Servers verändern müssen.

Wenn Sie vor der Installation von MySQL unter Windows Vista keinen Port geöffnet haben, können Sie den MySQL Server-Konfigurations-Assistenten nach der Installation verwenden. Allerdings müssen Sie einen Port in der Windows-Firewall öffnen. Die Anweisungen dazu finden Sie in Abschnitt 2.3.3.1, „Herunterladen und Starten des MySQL-Installations-Assistenten“. Anstatt einen Port zu öffnen, können Sie auch MySQL als Programm hinzufügen, das den Windows Firewall umgeht. Eine der beiden Optionen ist ausreichend – Sie müssen nicht beide ausführen. Wenn Sie den MySQL Server-Konfigurations-Assistenten unter Windows Vista ausführen, müssen Sie außerdem sicherstellen, dass Sie als Benutzer mit Administratorrechten angemeldet sind.

Sie können den MySQL Server-Konfigurations-Assistenten durch Auswahl des Eintrags MySQL Server Instance Config Wizard im Abschnitt MySQL des Windows-Menüs Start aufrufen.

Alternativ navigieren Sie zum Verzeichnis bin Ihrer MySQL-Installation und rufen die Datei MySQLInstanceConfig.exe direkt auf.

Der MySQL Server-Konfigurations-Assistent legt die Datei my.ini im Installationsverzeichnis des MySQL Servers ab. Dies erleichtert die Zuordnung von Konfigurationsdateien zu bestimmten Serverinstanzen.

Um sicherzustellen, dass der MySQL Server weiß, wo er nach der Datei my.ini suchen muss, wird im Zuge der Dienstinstallation ein Argument ähnlich dem folgenden an den MySQL Server übergeben:

--defaults-file="C:\Program Files\MySQL\MySQL Server 5.1\my.ini"

Hierbei wird C:\Program Files\MySQL\MySQL Server 5.1 durch den Installationspfad des MySQL Servers ersetzt. Die Option --defaults-file weist den MySQL Server an, beim Start die Konfigurationsoptionen aus der angegebenen Datei auszulesen.

Neben Änderungen, die Sie an der Datei my.ini durch nochmaliges Ausführen des MySQL Server-Konfigurations-Assistenten vornehmen, können Sie sie auch ändern, indem Sie sie mit einem Texteditor öffnen und notwendige Änderungen vornehmen. Sie können die Serverkonfiguration auch mit dem Hilfsprogramm MySQL Administrator bearbeiten. Weitere Informationen zur Serverkonfiguration finden Sie in Server Command Options.

MySQL-Clients und Hilfsprogramme wie die Befehlszeilenclients mysql und mysqldump können die Datei my.ini im Serverinstallationsverzeichnis nicht lokalisieren. Um Client- und Hilfsprogrammanwendungen zu konfigurieren, erstellen Sie eine neue my.ini-Datei im Windows-Installationsverzeichnis (zum Beispiel C:\WINDOWS).

Unter Windows Server 2003, Windows Server 2000, Windows XP und Windows Vista konfiguriert der MySQL Server-Konfigurations-Assistent MySQL als Windows-Dienst. Zum Starten und Beenden von MySQL verwenden Sie die Anwendung Services, die Bestandteil der Windows-Verwaltung ist.

Wenn der MySQL Server-Konfigurations-Assistent eine vorhandene Konfigurationsdatei erkennt, können Sie wahlweise den vorhandenen Server umkonfigurieren oder die Serverinstanz durch Löschen der Konfigurationsdatei entfernen und den MySQL-Dienst beenden und entfernen.

Wenn Sie den vorhandenen Server umkonfigurieren wollen, wählen Sie die Option Re-configure Instance und klicken dann auf die Schaltfläche Next. Vorhandene Konfigurationsdateien werden nicht überschrieben, aber (innerhalb desselben Dateiverzeichnisses) mithilfe eines Zeitstempels (Windows) oder einer laufenden Nummer (Linux) umbenannt. Wenn Sie die vorhandene Serverinstanz entfernen wollen, wählen Sie die Option Remove Instance und klicken dann auf die Schaltfläche Next.

Wählen Sie die Option Remove Instance, dann wird ein Bestätigungsfenster aufgerufen. Klicken Sie auf die Schaltfläche Execute. Der MySQL Server-Konfigurations-Assistent beendet und entfernt nun den MySQL-Dienst. Anschließend löscht er die Konfigurationsdatei. Die Serverinstallation und ihr Ordner data werden nicht entfernt.

Wenn Sie die Option Re-configure Instance auswählen, wird das Dialogfeld Configuration Type angezeigt. Hier können Sie den Installationstyp auswählen, den Sie konfigurieren wollen.

Wenn Sie den MySQL Server-Konfigurations-Assistenten für eine neue MySQL-Installation aufrufen oder die Option Re-configure Instance für eine vorhandene Installation auswählen, wird das Dialogfeld Configuration Type aufgerufen.

Es stehen zwei Konfigurationsmethoden zur Verfügung: Detailed Configuration und Standard Configuration. Die Option Standard Configuration ist für Neubenutzer vorgesehen, die direkt mit MySQL arbeiten wollen, ohne sich vorher Gedanken zur Serverkonfiguration machen zu müssen. Die Option Detailed Configuration ist hingegen für fortgeschrittene Benutzer gedacht, die eine exaktere Kontrolle über die Serverkonfiguration wünschen.

Wenn Sie noch nicht mit MySQL gearbeitet haben und einen Server benötigen, der als Entwicklersystem für genau einen Benutzer vorgesehen ist, dann ist Standard Configuration die richtige Wahl für Ihre Bedürfnisse. Wenn Sie die Option Standard Configuration wählen, stellt der MySQL Server-Konfigurations-Assistent alle Konfigurationsoptionen mit Ausnahme von Service Options (Dienstoptionen) und Security Options (Sicherheitsoptionen) automatisch ein.

Unter Umständen werden bei Auswahl von Standard Configuration Optionseinstellungen vorgenommen, die mit Systemen, auf denen bereits MySQL-Installationen vorhanden sind, nicht kompatibel sind. Ist auf dem System, auf dem Sie eine MySQL-Installation konfigurieren wollen, bereits eine andere MySQL-Installation vorhanden, dann wird die Auswahl Detailed Configuration empfohlen.

Um die Auswahl Standard Configuration fertig zu stellen, lesen Sie bitte die Abschnitte zu Service Options und Security Options in Abschnitt 2.3.4.10, „Der Dialog zu Dienstoptionen“ bzw. Abschnitt 2.3.4.11, „Der Dialog zu Sicherheitsoptionen“.

Sie können zwischen drei verschiedenen Servertypen wählen. Welchen Servertyp Sie wählen, wirkt sich auf die Entscheidungen aus, die der MySQL Server-Konfigurations-Assistent in den Bereichen Speicher-, Festplatten- und Prozessornutzung trifft.

Das Dialogfeld Database Usage erlaubt Ihnen die Angabe von Speicher-Engines, die Sie bei der Erstellung von MySQL-Tabellen voraussichtlich verwenden werden. Die hier gewählte Option bestimmt, ob die InnoDB-Speicher-Engine verfügbar ist und welcher Anteil der Serverressourcen für InnoDB bereitgestellt wird.

Der Konfigurations-Assistent verwendet eine Vorlage für die Generierung der Serverkonfigurationsdatei. Mit dem Dialogfeld Database Usage wird einer der folgenden Optionsstrings festgelegt:

Multifunctional Database:        MIXED
Transactional Database Only:     INNODB
Non-Transactional Database Only: MYISAM

Wenn diese Optionen durch die Standardvorlage bearbeitet werden (my-template.ini), ergibt sich folgendes Ergebnis:

Multifunctional Database:
default-storage-engine=InnoDB
_myisam_pct=50
Transactional Database Only:
default-storage-engine=InnoDB
_myisam_pct=5
Non-Transactional Database Only:
default-storage-engine=MyISAM
_myisam_pct=100
skip-innodb

Der Wert _myisam_pct wird verwendet, um den Prozentsatz der für MyISAM reservierten Ressourcen zu berechnen. Die übrigen Ressourcen werden InnoDB zugewiesen.

Manche Benutzer wollen die InnoDB-Tablespace-Dateien an einer anderen Position als im MySQL Serverdatenverzeichnis speichern. Dies kann wünschenswert sein, wenn Ihr System über ein Speichergerät mit höherer Kapazität oder mehr Leistung verfügt (z. B. ein RAID-Speichersystem).

Um die Standardposition der InnoDB-Tablespace-Dateien zu ändern, wählen Sie ein anderes Laufwerk aus der Dropdown-Liste mit den Laufwerksbuchstaben aus und stellen dann in der Dropdown-Liste mit den Pfaden einen anderen Pfad ein. Um einen benutzerdefinierten Pfad zu erstellen, klicken Sie auf die Schaltfläche ....

Wenn Sie die Konfiguration eines vorhandenen Servers modifizieren, müssen Sie auf die Schaltfläche Modify klicken, bevor Sie den Pfad ändern. In dieser Situation müssen Sie die vorhandenen Tablespace-Dateien manuell an die neue Position verschieben, bevor Sie den Server starten.

Um zu verhindern, dass der Server keine Ressourcen mehr zugewiesen bekommt, ist es wichtig, die Anzahl gleichzeitiger Verbindungen zum MySQL Server zu begrenzen. Das Dialogfeld Concurrent Connections ermöglicht Ihnen die Angabe der erwarteten Auslastung Ihres Servers und stellt die Anzahl gleichzeitiger Verbindungen entsprechend ein. Es ist ferner möglich, die Anzahl gleichzeitiger Verbindungen manuell zu ändern.

Im Dialogfeld Networking Options aktivieren oder deaktivieren Sie die TCP/IP-Netzwerkunterstützung und konfigurieren die Portnummer, die zur Verbindung mit dem MySQL Server verwendet wird.

Standardmäßig ist die TCP/IP-Netzwerkunterstützung aktiviert. Um sie zu deaktivieren, entfernen Sie die Markierung des Kontrollkästchen Enable TCP/IP Networking.

Standardmäßig ist Port 3306 gewählt. Um den für den MySQL-Zugriff verwendeten Port zu ändern, wählen Sie im Dropdown-Feld eine neue Portnummer aus und geben die gewünschte Nummer direkt in das Dropdown-Feld ein. Wird die eingetragene Portnummer bereits verwendet, dann werden Sie aufgefordert, Ihre Eingabe zu bestätigen.

Über Server SQL Mode können Sie den strikten SQL-Servermodus aktivieren oder deaktivieren. Bei aktiviertem striktem Modus (Standard) verhält sich MySQL ähnlich wie andere Datenbankmanagementsysteme. Wenn Sie Anwendungen ausführen, die auf das vorherige „nachsichtige“ Verhalten von MySQL angewiesen sind, müssen Sie diese Anwendungen entweder anpassen oder den strikten Modus deaktivieren. Weitere Informationen zum strikten Modus finden Sie in Server SQL Modes.

Der MySQL Server unterstützt mehrere Zeichensätze. In diesem Zusammenhang ist es möglich, einen Standardzeichensatz einzustellen, der für alle Tabellen, Spalten und Datenbanken verwendet wird, soweit nichts anderes explizit festgelegt ist. Im Dialogfeld Character Set können Sie den Standardzeichensatz des MySQL Servers ändern.

Auf Windows-Plattformen kann der MySQL Server als Windows-Dienst installiert werden. Wenn der Server auf diese Weise installiert wird, kann er beim Systemstart automatisch gestartet werden. Zudem ist auch ein automatischer Neustart des Dienstes durch Windows nach einem Ausfall möglich.

Der MySQL Server-Konfigurations-Assistent installiert den MySQL Server standardmäßig als Dienst mit dem Dienstnamen MySQL. Wollen Sie den Dienst nicht installieren, dann deaktivieren Sie das Kontrollkästchen Install As Windows Service. Sie können den Namen des Dienstes ändern, indem Sie einen anderen Namen im vorhandenen Dropdown-Feld auswählen oder einen neuen Dienstnamen direkt in das Feld eintragen.

Um den MySQL Server als Dienst zu installieren, der aber beim Systemstart nicht automatisch gestartet wird, deaktivieren Sie das Kontrollkästchen Launch the MySQL Server Automatically.

Es wird dringend empfohlen, ein root-Kennwort für Ihren MySQL Server einzurichten. Der MySQL Server-Konfigurations-Assistent fordert Sie standardmäßig dazu auf. Wollen Sie kein root-Kennwort erstellen, dann deaktivieren Sie das Kontrollkästchen Modify Security Settings.

Um das root-Kennwort einzurichten, geben Sie das gewünschte Kennwort in die Felder New root password und Confirm ein. Wenn Sie einen vorhandenen Server umkonfigurieren, müssen Sie das vorhandene root-Passwort in das Feld Current root password eingeben.

Um root-Anmeldungen über das Netzwerk zuzulassen, aktivieren Sie das Kontrollkästchen Enable root access from remote machines. Dies vermindert die Sicherheit Ihres root-Kontos.

Um ein anonymes Benutzerkonto einzurichten, markieren Sie das Kontrollkästchen Create An Anonymous Account . Die Erstellung eines solchen Kontos kann die Serversicherheit verringern und Probleme mit der Anmeldung und mit Berechtigungen verursachen. Aus diesem Grund wird davon abgeraten.

Das letzte Dialogfeld im MySQL Server-Konfigurations-Assistenten ist Confirmation Dialog. Um den Konfigurationsvorgang zu starten, klicken Sie auf die Schaltfläche Execute. Wenn Sie zu einem der vorherigen Dialogfelder zurückkehren wollen, klicken Sie auf die Schaltfläche Back. Um den MySQL Server-Konfigurations-Assistenten zu verlassen, ohne MySQL zu konfigurieren, klicken Sie auf die Schaltfläche Cancel.

Wenn Sie auf die Schaltfläche Execute geklickt haben, führt der MySQL Server-Konfigurations-Assistent eine Reihe von Aufgaben aus und zeigt deren Fortschritt auf dem Bildschirm an.

Der MySQL Server-Konfigurations-Assistent ermittelt zunächst die Konfigurationsdateioptionen basierend auf Ihren Einstellungen. Hierzu verwendet er eine Vorlage, die von Entwicklern und Technikern bei MySQL erstellt wurde. Diese Vorlage heißt my-template.ini und befindet sich in Ihrem Serverinstallationsverzeichnis.

Der MySQL Server-Konfigurations-Assistent schreibt diese Optionen dann in die entsprechende Konfigurationsdatei.

Wenn Sie angegeben haben, dass ein Dienst für den MySQL Server eingerichtet werden soll, erstellt und startet der MySQL Server-Konfigurations-Assistent diesen Dienst. Konfigurieren Sie einen vorhandenen Dienst um, dann startet der MySQL Server-Konfigurations-Assistent den Dienst neu, um Ihre Konfigurationsänderungen anzuwenden.

Haben Sie angegeben, dass ein root-Kennwort eingerichtet werden soll, dann stellt der MySQL Server-Konfigurations-Assistent eine Verbindung mit dem Server her, richtet Ihr neues root-Kennwort ein und übernimmt ggf. weitere von Ihnen gewählte Sicherheitseinstellungen.

Wenn der MySQL Server-Konfigurations-Assistent seine Aufgaben abgeschlossen hat, wird eine Zusammenfassung angezeigt. Klicken Sie auf die Schaltfläche Finish, um den MySQL Server-Konfigurations-Assistenten zu beenden.