Kapitel 1. Das mysql-Client-Programm verwenden

Diese Arbeit wurde mithilfe von KI übersetzt. Wir freuen uns über dein Feedback und deine Kommentare: translation-feedback@oreilly.com

1.0 Einleitung

Das MySQL-Datenbanksystem verwendet eine Client-Server-Architektur. Der Server, mysqld, ist das Programm, das die Datenbanken bearbeitet. Um dem Server mitzuteilen, was er tun soll, verwendest du ein Client-Programm, das deine Absicht mit Hilfe von SQL-Anweisungen kommuniziert. Client-Programme werden für unterschiedliche Zwecke geschrieben, aber alle interagieren mit dem Server, indem sie sich mit ihm verbinden, SQL-Anweisungen senden, um Datenbankoperationen durchzuführen, und die Ergebnisse empfangen.

Die Clients werden lokal auf dem Rechner installiert, von dem aus du auf MySQL zugreifen willst, aber der Server kann überall installiert sein, solange die Clients eine Verbindung zu ihm herstellen können. Da MySQL von Haus aus ein vernetztes Datenbanksystem ist, können Clients mit einem Server kommunizieren, der lokal auf deinem eigenen Rechner oder irgendwo auf der anderen Seite des Planeten läuft.

Das Programm mysql ist einer der Clients, die in den MySQL-Distributionen enthalten sind. Bei interaktiver Verwendung fordert mysql dich zur Eingabe einer Anweisung auf, sendet sie zur Ausführung an den MySQL-Server und zeigt die Ergebnisse an. mysql kann auch nicht-interaktiv im Batch-Modus verwendet werden, um Anweisungen zu lesen, die in Dateien gespeichert oder von Programmen erzeugt wurden. Dies ermöglicht die Verwendung von mysql innerhalb von Skripten oder cron Aufträgen oder in Verbindung mit anderen Anwendungen.

In diesem Kapitel werden die Funktionen von mysqlbeschrieben, damit du sie effektiver nutzen kannst:

  • Einrichten eines MySQL-Kontos unter Verwendung der Datenbank cookbook

  • Festlegen von Verbindungsparametern und Verwendung von Optionsdateien

  • Interaktives Ausführen von SQL-Anweisungen und im Batch-Modus

  • Steuerung des mysql Ausgabeformats

  • Benutzerdefinierte Variablen zum Speichern von Informationen verwenden

Um die in diesem Buch gezeigten Beispiele auszuprobieren, brauchst du ein MySQL-Benutzerkonto und eine Datenbank. Die ersten beiden Rezepte in diesem Kapitel beschreiben, wie du diese mit mysql einrichtest, basierend auf diesen Voraussetzungen:

  • Der MySQL-Server läuft lokal auf deinem eigenen System

  • Dein MySQL-Benutzername und Passwort sind cbuser und cbpass

  • Deine Datenbank heißt cookbook

Wenn du magst, kannst du gegen jede der Annahmen verstoßen. Dein Server muss nicht lokal laufen, und du musst nicht den Benutzernamen, das Passwort oder den Datenbanknamen verwenden, die in diesem Buch verwendet werden. In solchen Fällen musst du die Beispiele natürlich entsprechend abändern.

Auch wenn du cookbook nicht als Datenbanknamen verwendest, empfehlen wir dir, eine Datenbank für die hier gezeigten Beispiele zu verwenden und nicht eine, die du auch für andere Zwecke nutzt. Andernfalls kann es zu Konflikten zwischen den Namen bestehender Tabellen und den in den Beispielen verwendeten kommen, und du musst Änderungen vornehmen, die bei einer speziellen Datenbank unnötig wären.

Die Skripte, die die in diesem Kapitel verwendeten Tabellen erstellen, befinden sich im Verzeichnis tables der Distribution recipes, die dem MySQL Cookbook beiliegt. Andere Skripte befinden sich im Verzeichnis mysql. Um die recipes Distribution zu erhalten, lies das Vorwort.

1.1 Einrichten eines MySQL-Benutzerkontos

Problem

Du brauchst ein Konto für die Verbindung zu deinem MySQL-Server.

Lösung

Verwende CREATE USER und GRANT Anweisungen, um das Konto einzurichten. Verwende dann den Kontonamen und das Passwort, um Verbindungen zum Server herzustellen.

Diskussion

Für die Verbindung zu einem MySQL-Server benötigst du einen Benutzernamen und ein Passwort. Eventuell musst du auch den Namen des Hosts angeben, auf dem der Server läuft. Wenn du die Verbindungsparameter nicht explizit angibst, nimmt mysql Standardwerte an. Wenn du zum Beispiel keinen expliziten Hostnamen angibst, geht mysql davon aus, dass der Server auf dem lokalen Rechner läuft.

Wenn jemand anderes bereits ein Konto für dich eingerichtet und dir die Rechte zum Erstellen und Ändern der Datenbank cookbook erteilt hat, verwende dieses Konto. Andernfalls zeigt das folgende Beispiel, wie du das Programm mysql verwendest, um dich mit dem Server zu verbinden und die Anweisungen einzugeben, die ein Benutzerkonto mit den Rechten für den Zugriff auf eine Datenbank namens cookbook einrichten. Die Argumente für mysql sind -hlocalhost , um sich mit dem MySQL-Server auf dem lokalen Host zu verbinden, -u root , um sich als MySQL-Benutzer root zu verbinden, und -p, um mysql zur Eingabeaufforderung für ein Passwort zu veranlassen:

$ mysql -h localhost -u root -p
Enter password: ******
Welcome to the MySQL monitor.  Commands end with ; or \g.
Your MySQL connection id is 54117
Server version: 8.0.27 MySQL Community Server - GPL

Copyright (c) 2000, 2021, Oracle and/or its affiliates.

Oracle is a registered trademark of Oracle Corporation and/or its
affiliates. Other names may be trademarks of their respective
owners.

Type 'help;' or '\h' for help. Type '\c' to clear the current input statement.

mysql> CREATE USER 'cbuser'@'localhost' IDENTIFIED BY 'cbpass';
mysql> GRANT ALL ON cookbook.* TO 'cbuser'@'localhost';
Query OK, 0 rows affected (0.09 sec)
mysql> GRANT PROCESS ON *.* to  `cbuser`@`localhost` ;
Query OK, 0 rows affected (0,01 sec)
mysql> quit
Bye
Tipp

Die Berechtigung PROCESS ist erforderlich, wenn du eine Dump-Datei deiner MySQL-Daten erstellen möchtest. Siehe auch Rezept 1.4.

Wenn du versuchst, mysql aufzurufen und eine Fehlermeldung erhältst, dass es nicht gefunden wird oder ein ungültiger Befehl ist, bedeutet das, dass dein Befehlsinterpreter nicht weiß, wo mysql installiert ist. In Rezept 1.3 erfährst du, wie du die Umgebungsvariable PATH setzen kannst, die der Interpreter verwendet, um Befehle zu finden.

In den gezeigten Befehlen steht die $für die Eingabeaufforderung, die von deiner Shell oder deinem Befehlsinterpreter angezeigt wird, und mysql> für die Eingabeaufforderung, die von mysql angezeigt wird. Text, den du eingibst, wird fett dargestellt. Nicht fett gedruckter Text (einschließlich der Eingabeaufforderungen) ist die Programmausgabe; tippe nichts davon ein.

Wenn mysql die Eingabeaufforderung für das Passwort ausgibt, gibst du das MySQL-Passwort root an der Stelle ein, an der du ****** siehst. Wenn der MySQL-Benutzer root kein Passwort hat, drückst du bei der Eingabeaufforderung einfach die Enter- (oder Return-) Taste. Daraufhin wird die Eingabeaufforderung für MySQL angezeigt, die je nach verwendeter MySQL-Version etwas anders aussehen kann. Gib dann die Anweisungen CREATE USER und GRANT wie gezeigt ein.

Mit dem Befehl quit beendest du deine mysqlSitzung. Du kannst eine Sitzung auch mit dem Befehl oder (unter Unix) durch Eingabe von Strg-D beenden. exit

Um dem Konto cbuser Zugriff auf eine andere Datenbank als cookbook zu gewähren, ersetze den Namen der Datenbank an der Stelle, an der cookbook steht, in der Anweisung GRANT. Um einem bestehenden Konto den Zugriff auf die Datenbank cookbook zu gewähren, lässt du die Anweisung CREATE USER weg und ersetzt dieses Konto durch 'cbuser'@'localhost' in der Anweisung GRANT.

Hinweis

Der MySQL-Benutzerkontosatz enthält zwei Teile: den Benutzernamen und den Host. Der Benutzername ist eine Kennung für den Benutzer, der auf den MySQL-Server zugreift. Du kannst für diesen Teil alles angeben. Der Hostname ist die IP-Adresse oder der Name des Hosts, von dem aus sich dieser Benutzer mit dem MySQL-Server verbindet. Wir besprechen das MySQL-Sicherheitsmodell und die Benutzerkonten in Rezept 24.0.

Der Teil hostname von 'cbuser'@'localhost' gibt den Host an, von dem aus du dich mit dem MySQL-Server verbinden wirst. Um ein Konto einzurichten, das eine Verbindung zu einem Server auf dem lokalen Rechner herstellt, verwendest du die Anweisung localhost, wie gezeigt. Wenn du dich von einem anderen Host aus mit dem Server verbinden willst, ersetze diesen Host in den Anweisungen CREATE USER und GRANT. Wenn du dich zum Beispiel von einem Host namens myhost.example.com aus mit dem Server verbinden willst, sehen die Anweisungen wie folgt aus:

mysql> CREATE USER 'cbuser'@'myhost.example.com' IDENTIFIED BY 'cbpass';
mysql> GRANT ALL ON cookbook.* TO 'cbuser'@'myhost.example.com';

Vielleicht ist dir aufgefallen, dass es in dem gerade beschriebenen Verfahren ein Paradoxon gibt: um ein cbuser Konto einzurichten, das sich mit dem MySQL-Server verbinden kann, musst du dich zuerst mit dem Server verbinden, damit du die CREATE USER und GRANT Anweisungen ausführen kannst. Ich gehe davon aus, dass du dich bereits als MySQL-Benutzer rootverbinden kannst, da CREATE USER und GRANT nur von einem Benutzer wie root verwendet werden können, der die administrativen Rechte hat, die zum Einrichten anderer Benutzerkonten erforderlich sind. Wenn du dich nicht als root mit dem Server verbinden kannst, bitte deinen MySQL-Administrator, das Konto cbuserfür dich zu erstellen.

Nachdem du das Konto cbusererstellt hast, überprüfe, ob du dich damit mit dem MySQL-Server verbinden kannst. Führen Sie dazu von dem Host aus, der in der Anweisung CREATEUSER genannt wurde, den folgenden Befehl aus (der Host, der nach -h genannt wird, sollte der Host sein, auf dem der MySQL-Server läuft):

$ mysql -h localhost -u cbuser -p
Enter password: cbpass

Jetzt kannst du die Datenbank cookbook und die Tabellen darin erstellen, wie in Rezept 1.2 beschrieben. Um den Aufruf von mysql zu erleichtern, ohne jedes Mal Verbindungsparameter angeben zu müssen, kannst du diese in eine Optionsdatei schreiben (siehe Rezept 1.4).

Siehe auch

Weitere Informationen zur Verwaltung von MySQL-Konten findest du in Kapitel 24.

1.2 Erstellen einer Datenbank und einer Beispieltabelle

Problem

Du möchtest eine Datenbank erstellen und darin Tabellen einrichten.

Lösung

Verwende eine CREATE DATABASE Anweisung, um die Datenbank zu erstellen, eine CREATE TABLE Anweisung für jede Tabelle und INSERT Anweisungen, um Zeilen zu den Tabellen hinzuzufügen.

Diskussion

Die in Rezept 1.1 gezeigte Anweisung GRANT richtet die Berechtigungen für den Zugriff auf die Datenbank cookbook ein, erstellt aber nicht die Datenbank. In diesem Abschnitt wird gezeigt, wie man das macht und wie man eine Tabelle erstellt und sie mit den Beispieldaten lädt, die in den folgenden Abschnitten als Beispiele verwendet werden. Ähnliche Anweisungen gelten für die Erstellung anderer Tabellen, die an anderer Stelle in diesem Buch verwendet werden.

Verbinde dich mit dem MySQL-Server, wie am Ende von Rezept 1.1 gezeigt, und erstelle dann die Datenbank wie folgt:

mysql> CREATE DATABASE cookbook;

Jetzt, wo du eine Datenbank hast, kannst du Tabellen darin erstellen. Wähle zunächst cookbook als Standarddatenbank aus:

mysql> USE cookbook;

Dann erstelle eine einfache Tabelle:

mysql> CREATE TABLE limbs (thing VARCHAR(20), legs INT, arms INT, PRIMARY KEY(thing));

Und fülle sie mit ein paar Zeilen:

mysql> INSERT INTO limbs (thing,legs,arms) VALUES('human',2,2);
mysql> INSERT INTO limbs (thing,legs,arms) VALUES('insect',6,0);
mysql> INSERT INTO limbs (thing,legs,arms) VALUES('squid',0,10);
mysql> INSERT INTO limbs (thing,legs,arms) VALUES('fish',0,0);
mysql> INSERT INTO limbs (thing,legs,arms) VALUES('centipede',99,0);
mysql> INSERT INTO limbs (thing,legs,arms) VALUES('table',4,0);
mysql> INSERT INTO limbs (thing,legs,arms) VALUES('armchair',4,2);
mysql> INSERT INTO limbs (thing,legs,arms) VALUES('phonograph',0,1);
mysql> INSERT INTO limbs (thing,legs,arms) VALUES('tripod',3,0);
mysql> INSERT INTO limbs (thing,legs,arms) VALUES('Peg Leg Pete',1,2);
mysql> INSERT INTO limbs (thing,legs,arms) VALUES('space alien',NULL,NULL);
Tipp

Um die INSERT Anweisungen einfacher einzugeben, drückst du nach der Eingabe der ersten Anweisung den Pfeil nach oben, um sie aufzurufen, drückst ein paar Mal die Rücktaste (oder Entf), um die Zeichen bis zur letzten offenen Klammer zu löschen, und gibst dann die Datenwerte für die nächste Anweisung ein. Wenn du dir die Eingabe der INSERT Anweisungen ganz ersparen willst, kannst du auch mit Rezept 1.6 weitermachen.

Die Tabelle, die du gerade erstellt hast, heißt limbs und enthält drei Spalten, in denen die Anzahl der Beine und Arme verschiedener Lebensformen und Objekte festgehalten wird. Die Physiologie des Außerirdischen in der letzten Zeile ist so beschaffen, dass die richtigen Werte für die Spalten arms und legs nicht ermittelt werden können; NULLbedeutet unbekannter Wert.

Die PRIMARY KEY Klausel definiert den Primärschlüssel, der die Tabellenzeile eindeutig identifiziert. Dies verhindert, dass mehrdeutige Daten in die Tabelle eingefügt werden, und hilft MySQL außerdem, Abfragen schneller durchzuführen. Wir besprechen mehrdeutige Daten in Kapitel 18 und Leistungsprobleme in Kapitel 21.

Überprüfe, ob die Zeilen zur Tabelle limbs hinzugefügt wurden, indem du eine SELECT Anweisung ausführst:

mysql> SELECT * FROM limbs;
+--------------+------+------+
| thing        | legs | arms |
+--------------+------+------+
| human        |    2 |    2 |
| insect       |    6 |    0 |
| squid        |    0 |   10 |
| fish         |    0 |    0 |
| centipede    |   99 |    0 |
| table        |    4 |    0 |
| armchair     |    4 |    2 |
| phonograph   |    0 |    1 |
| tripod       |    3 |    0 |
| Peg Leg Pete |    1 |    2 |
| space alien  | NULL | NULL |
+--------------+------+------+
11 rows in set (0,01 sec)

Jetzt hast du eine Datenbank und eine Tabelle eingerichtet. Weitere Informationen zum Ausführen von SQL-Anweisungen findest du in den Rezepten 1.5 und 1.6 .

Hinweis

In diesem Buch werden die SQL-Schlüsselwörter wie z.B. SELECT oder INSERT zur besseren Unterscheidung in Großbuchstaben dargestellt. Das ist nur eine typografische Konvention; Schlüsselwörter können in jeder beliebigen Schreibweise verwendet werden.

1.3 Den mysql-Client finden

Problem

Wenn du mysql client über die Befehlszeile aufrufst, kann dein Befehlsinterpreter ihn nicht finden.

Lösung

Füge das Verzeichnis, in dem mysqlinstalliert ist, zu deiner PATH Einstellung hinzu. Dann kannst du mysql ganz einfach von jedem Verzeichnis aus starten.

Diskussion

Wenn deine Shell oder dein Befehlsinterpreter mysql nicht finden kann, wenn du ihn aufrufst, siehst du eine Fehlermeldung. Unter Unix könnte sie so aussehen:

$ mysql
mysql: Command not found.

Oder so unter Windows:

C:\> mysql.exe
'mysql.exe' is not recognized as an internal or external command,↩
operable program or batch file.

Eine Möglichkeit, deinem Befehlsinterpreter mitzuteilen, wo er mysql finden kann, ist, jedes Mal den vollständigen Pfadnamen einzugeben, wenn du ihn ausführst. Unter Unix könnte der Befehl folgendermaßen aussehen:

$ /usr/local/mysql/bin/mysql

Oder so unter Windows:

C:\> "C:\Program Files\MySQL\MySQL Server 8.0\bin\mysql"

Das Eingeben langer Pfadnamen wird schnell lästig. Du kannst dies vermeiden, indem du in das Verzeichnis wechselst, in dem mysql installiert ist, bevor du es ausführst. Aber wenn du das tust, könntest du versucht sein, alle deine Datendateien und SQL-Batchdateien in dasselbe Verzeichnis wie mysql zu legen und so einen Speicherort, der nur für Programme gedacht ist, unnötig zu verstopfen.

Eine bessere Lösung ist es, die Umgebungsvariable PATH search-path zu ändern, die Verzeichnisse angibt, in denen der Befehlsinterpreter nach Befehlen sucht. Füge dem Wert PATH das Verzeichnis hinzu, in dem mysql installiert ist. Dann kannst du mysql von jedem beliebigen Ort aus aufrufen, indem du nur den Namen eingibst, wodurch die Eingabe von Pfadnamen entfällt. Wie du die Variable PATHsetzt, erfährst du in "Executing Programs from the Command Line" auf dem dazugehörigen GitHub-Repository (siehe Vorwort).

Unter Windows gibt es noch eine andere Möglichkeit, um zu vermeiden, dass den Pfadnamen eintippt oder in das Verzeichnis mysql wechselt, indem du eine Verknüpfung erstellst und sie an einem günstigeren Ort, z. B. auf dem Desktop, platzierst. So kannst du mysql ganz einfach starten, indem du die Verknüpfung öffnest. Um Befehlsoptionen oder das Startverzeichnis festzulegen, bearbeitest du die Eigenschaften der Verknüpfung. Wenn du mysql nicht immer mit den gleichen Optionen aufrufst, kann es sinnvoll sein, für jede benötigte Option eine eigene Verknüpfung zu erstellen. Erstelle z. B. eine Verknüpfung, um dich als normaler Benutzer für allgemeine Arbeiten zu verbinden, und eine weitere, um dich als Benutzer MySQL root für administrative Zwecke zu verbinden.

1.4 Festlegen der mysql-Befehlsoptionen

Problem

Wenn du das Programm mysqlohne Befehlsoptionen aufrufst, beendet es sich sofort mit einer Fehlermeldung.

Lösung

Du musst Verbindungsparameter angeben. Dies kannst du in der Befehlszeile, in einer Optionsdatei oder in einer Mischung aus beidem tun.

Diskussion

Wenn du mysql ohne Befehlsoptionen aufrufst, kann das Ergebnis ein Fehler sein , der den Zugriff verweigert. Um das zu vermeiden, verbindest du dich mit dem MySQL-Server wie in Rezept 1.1 gezeigt, indem du mysql wie folgt verwendest:

$ mysql -h localhost -u cbuser -p
Enter password: cbpass

Jede Option ist die einsträngige Kurzform: -h und -u, um den Hostnamen und den Benutzernamen anzugeben, und -p, um eine Eingabeaufforderung für das Passwort zu erhalten. Es gibt auch entsprechende Langformen mit Doppelstrich: --host, --user, und --password. Verwende sie wie folgt:

$ mysql --host=localhost --user=cbuser --password
Enter password: cbpass

Um alle Optionen zu sehen, die mysql unterstützt, benutze diesen Befehl:

$ mysql --help

Die Art und Weise, wie du die Befehlsoptionen für mysql angibst, gilt auch für andere MySQL-Programme wie mysqldump und mysqladmin. Um zum Beispiel eine Dump-Datei mit dem Namen cookbook.sql zu erzeugen, die eine Sicherung der Tabellen in der Datenbank cookbook enthält, führe mysqldump wie folgt aus:

$ mysqldump -h localhost -u cbuser -p cookbook > cookbook.sql
Enter password: cbpass

Einige Operationen erfordern ein administratives MySQL-Konto. Das Programm mysqladmin kann Vorgänge ausführen, die nur für das MySQL-Konto root verfügbar sind. Um zum Beispiel den Server zu stoppen, rufst du mysqladmin wie folgt auf:

$ mysqladmin -h localhost -u root -p shutdown
Enter password:        ← enter MySQL root account password here

Wenn der Wert, den du für eine Option verwendest, derselbe ist wie der Standardwert, kannst du die Option weglassen. Es gibt jedoch kein Standardkennwort. Wenn du möchtest, kannst du das Kennwort direkt in der Befehlszeile angeben, indem du -ppassword ( ohne Leerzeichen zwischen der Option und dem Passwort) oder --password=password.

Warnung

Wir raten davon ab, weil das Passwort für andere sichtbar ist und auf Systemen mit mehreren Benutzern möglicherweise von anderen Benutzern entdeckt werden kann, die Tools wie ps ausführen, die Prozessinformationen melden oder den Inhalt deiner Shell-History-Datei lesen können.

Da der Standard-Host localhost ist, derselbe Wert, den wir explizit angegeben haben, kannst du die Option -h (oder --host) in der Befehlszeile weglassen:

$ mysql -u cbuser -p

Aber nehmen wir an, dass du lieber keine Optionen angeben möchtest. Wie kannst du mysql dazu bringen, einfach zu wissen, welche Werte du verwenden sollst? Das ist ganz einfach, denn die MySQL-Programme unterstützen Optionsdateien:

  • Wenn du eine Option in eine Optionsdatei einträgst, musst du sie nicht jedes Mal auf der Kommandozeile angeben, wenn du ein bestimmtes Programm aufrufst.

  • Du kannst Optionen aus der Befehlszeile und aus der Optionsdatei mischen. So kannst du die am häufigsten verwendeten Optionswerte in einer Datei speichern, sie aber in der Befehlszeile nach Belieben überschreiben.

Der Rest dieses Abschnitts beschreibt diese Fähigkeiten.

Festlegen von Verbindungsparametern mithilfe von Optionsdateien

Um zu vermeiden, dass du bei jedem Aufruf vonmysql Optionen in die Befehlszeile eingibst, kannst du sie in eine Optionsdatei schreiben, die mysql automatisch liest. Optionsdateien sind reine Textdateien:

  • Unter Unix heißt deine persönliche Optionsdatei .my.cnfin deinem Home-Verzeichnis. Es gibt auch standortweite Optionsdateien, die Administratoren verwenden können, um Parameter festzulegen, die global für alle Benutzer gelten. Du kannst die Datei my.cnf im Verzeichnis /etc oder /etc/mysql oder im Verzeichnis etc unter dem MySQL-Installationsverzeichnis verwenden.

  • Unter Windows kannst du die Datei my.ini oder my.cnf in deinem MySQL-Installationsverzeichnis (z.B. C:\Programme\MySQL\MySQL Server 8.0), in deinem Windows-Verzeichnis (wahrscheinlich C:\WINDOWS) oder im Verzeichnis C:\ verwenden.

Um die genaue Liste der zulässigen Speicherorte für Optionsdateien zu sehen, rufe mysql --help auf.

Das folgende Beispiel veranschaulicht das Format, das in MySQLOptionsdateien verwendet wird:

# general client program connection options
[client]
host     = localhost
user     = cbuser
password = cbpass

# options specific to the mysql program
[mysql]
skip-auto-rehash
pager="/usr/bin/less -i" # specify pager for interactive mode

Mit den soeben gezeigten Verbindungsparametern in der Gruppe [client] kannst du dich als cbuser verbinden, indem du mysql ohne Optionen in der Befehlszeile aufrufst:

$ mysql

Das Gleiche gilt für andere MySQL-Client-Programme, wie z.B. mysqldump.

Warnung

Die Option password wird in der Konfigurationsdatei im Klartext gespeichert und jeder Benutzer, der Zugriff auf diese Datei hat, kann sie lesen. Wenn du die Verbindungsdaten schützen willst, solltest du mysql_config_editor verwenden, um sie sicher zu speichern.

mysql_config_editor speichert die Verbindungsdaten in einer Datei namens .mylogin.cnf, die sich unter Unix in deinem Home-Verzeichnis und unter Windows im Verzeichnis %APPDATA%\MySQL befindet. Sie unterstützt nur die Verbindungsparameter host, user, password und socket. Die Option --login-pathgibt eine Gruppe an, unter der die Anmeldedaten gespeichert werden. Der Standardwert ist [client].

Im Folgenden findest du ein Beispiel für die Verwendung von mysql_config_editor, um eine verschlüsselte Anmeldedatei zu erstellen:

$ mysql_config_editor set --login-path=client \
> --host=localhost --user=cbuser --password
Enter password: cbpass

# print stored credentials
$ mysql_config_editor print --all
[client]
user = cbuser
password = *****
host = localhost

MySQL-Optionsdateien haben diese Eigenschaften:

  • Die Zeilen werden in Gruppen (oder Abschnitten) geschrieben. In der ersten Zeile einer Gruppe wird der Gruppenname in eckigen Klammern angegeben, in den übrigen Zeilen werden die mit der Gruppe verbundenen Optionen angegeben. Die eben gezeigte Beispieldatei hat eine Gruppe [client] und eine Gruppe [mysql]. Um die Optionen für den Server mysqld anzugeben, füge sie in die Gruppe [mysqld] ein.

  • Die übliche Optionsgruppe für die Angabe der Client-Verbindungsparameter ist [client]. Diese Gruppe wird eigentlich von allen Standard-MySQL-Clients verwendet. Indem du eine Option in diese Gruppe aufnimmst, erleichterst du nicht nur den Aufruf von mysql, sondern auch von anderen Programmen wie mysqldumpund mysqladmin. Achte nur darauf, dass jede Option, die du in diese Gruppe einträgst, von allen Client-Programmen verstanden wird. Andernfalls führt der Aufruf eines Programms, das die Option nicht versteht, zu einer Fehlermeldung über eine unbekannte Option.

  • Du kannst mehrere Gruppen in einer Optionsdatei definieren. Normalerweise suchen MySQL-Clients nach Parametern in der Gruppe [client] und in der Gruppe, die nach dem Programm selbst benannt ist. Auf diese Weise kannst du allgemeine Client-Parameter auflisten, die alle Client-Programme verwenden sollen, aber du kannst auch Optionen angeben, die nur für ein bestimmtes Programm gelten. Die vorstehende Beispieloptionsdatei veranschaulicht diese Konvention für das Programm mysql, das allgemeine Verbindungsparameter aus der Gruppe [client] bezieht und außerdem die Optionen skip-auto-rehash und pager aus der Gruppe [mysql] aufnimmt.

  • Innerhalb einer Gruppe schreibst du Optionszeilen im name=value Format, wobei name einem Optionsnamen (ohne führende Bindestriche) entspricht und value der Wert der Option ist. Wenn eine Option keinen Wert hat (z. B. skip-auto-rehash), wird der Name selbst ohne abschließenden =value Teil.

  • In Optionsdateien ist nur die Langform einer Option erlaubt, nicht die Kurzform. In der Befehlszeile kann der Hostname zum Beispiel entweder mit -hangegeben werdenhost_name oder --host=host_nameIn einer Optionsdatei ist nur host=host_name erlaubt.

  • Viele Programme, darunter mysql und mysqld, haben zusätzlich zu den Befehlsoptionen Programmvariablen. (Auf dem Server heißen sie Systemvariablen; siehe Rezept 22.1.) Programmvariablen können genau wie Optionen in Optionsdateien angegeben werden. Intern werden Programmvariablennamen mit Unterstrichen geschrieben, aber in Optionsdateien kannst du Optionen und Variablen auch mit Bindestrichen oder Unterstrichen schreiben. skip-auto-rehash und skip_auto_rehash sind zum Beispiel gleichwertig. Um die Systemvariable sql_mode des Servers in einer [mysqld] Optionsgruppe zu setzen, sql_mode=value und sql-mode=value sind gleichwertig. (Die Austauschbarkeit von Bindestrich und Unterstrich gilt auch für Optionen oder Variablen, die in der Befehlszeile angegeben werden).

  • In Optionsdateien sind Leerzeichen um die = erlaubt, die einen Optionsnamen und -wert trennt. Im Gegensatz dazu sind in Befehlszeilen keine Leerzeichen um = erlaubt. Wenn ein Optionswert Leerzeichen oder andere Sonderzeichen enthält, kannst du ihn in einfache oder doppelte Anführungszeichen setzen. Die Option pager veranschaulicht dies.

  • Es ist üblich, eine Optionsdatei zu verwenden, um Optionen für Verbindungsparameter festzulegen (wie host, user und password). Die Datei kann aber auch Optionen für andere Zwecke enthalten. Die Option pager, die für die Gruppe [mysql] angezeigt wird, gibt das Auslagerungsprogramm an, das mysql für die Anzeige von Ausgaben im interaktiven Modus verwenden soll. Sie hat nichts damit zu tun, wie sich das Programm mit dem Server verbindet. Wir raten davon ab, password in die Optionsdatei aufzunehmen, da sie im Klartext gespeichert wird und von Benutzern entdeckt werden könnte, die Zugriff auf die Konfigurationsdatei haben, aber nicht unbedingt Zugriff auf die MySQL-Installation haben.

  • Wenn ein Parameter mehrmals in einer Optionsdatei vorkommt, hat der zuletzt gefundene Wert Vorrang. Normalerweise solltest du alle programmspezifischen Gruppen nach der Gruppe [client] auflisten, damit bei Überschneidungen zwischen den Optionen der beiden Gruppen die allgemeineren Optionen durch die programmspezifischen Werte überschrieben werden.

  • Zeilen, die mit # oder; Zeichen beginnen, werden als Kommentare ignoriert. Leerzeilen werden ebenfalls ignoriert. # kann verwendet werden, um Kommentare an das Ende von Optionszeilen zu schreiben, wie bei der Option pager gezeigt.

  • Optionen, die Datei- oder Verzeichnispfade angeben, sollten geschrieben werden, wobei / als Pfadtrennzeichen verwendet wird, auch unter Windows, das \ als Pfadtrennzeichen verwendet. Alternativ kannst du \ schreiben, indem du es als \\ verdoppelst (das ist notwendig, weil \ das MySQL-Escape-Zeichen in Zeichenketten ist).

Um herauszufinden, welche Optionen das Programm mysql aus den Optionsdateien liest, benutze diesen Befehl:

$ mysql --print-defaults

Du kannst auch das Dienstprogramm my_print_defaults verwenden,, das als Argumente die Namen der Optionsdateigruppen annimmt, die es lesen soll. mysqldump sucht zum Beispiel in den Gruppen [client] und [mysqldump] nach Optionen. Um zu prüfen, welche Einstellungen in den Optionsdateien in diesen Gruppen enthalten sind, kannst du diesen Befehl verwenden:

$ my_print_defaults client mysqldump

Mischen von Befehlszeilen- und Optionsdateiparametern

Es ist möglich, Befehlszeilenoptionen und Optionen in den Optionsdateienzu mischen. Vielleicht möchtest du deinen Benutzernamen und den Server-Host in einer Optionsdatei auflisten, aber dein Passwort nicht dort speichern. Das ist kein Problem: Die MySQL-Programme lesen zunächst deine Optionsdatei, um zu sehen, welche Verbindungsparameter dort aufgeführt sind, und suchen dann in der Befehlszeile nach zusätzlichen Parametern. Das bedeutet, dass du einige Optionen auf die eine und einige auf die andere Weise angeben kannst. Du kannst zum Beispiel deinen Benutzernamen und deinen Hostnamen in einer Optionsdatei angeben, aber in der Befehlszeile eine Passwortoption verwenden:

$ mysql -p
Enter password:        ← enter your password here

Kommandozeilenparameter haben Vorrang vor den Parametern in deiner Optionsdatei. Wenn du also einen Parameter aus der Optionsdatei überschreiben willst, gib ihn einfach in der Kommandozeile an. Du kannst zum Beispiel deinen normalen MySQL-Benutzernamen und dein Passwort in der Optionsdatei angeben, um sie allgemein zu verwenden. Wenn du dich dann gelegentlich mit dem MySQL-Benutzer root verbinden musst, gibst du die Benutzer- und Passwortoptionen in der Befehlszeile an, um die Werte in der Optionsdatei zu überschreiben:

$ mysql -u root -p
Enter password:        ← enter MySQL root account password here

Um explizit kein Passwort anzugeben, wenn in der Optionsdatei ein nicht leeres Passwort vorhanden ist, verwende --skip-password in der Befehlszeile:

$ mysql --skip-password
Hinweis

Von nun an zeigen wir in der Regel Befehle für MySQL-Programme ohne Optionen für die Verbindungsparameter. Wir gehen davon aus, dass du alle Parameter, die du brauchst, entweder auf der Kommandozeile oder in einer Optionsdatei angibst.

Schutz von Optionsdateien vor anderen Nutzern

Auf einem Mehrbenutzer-Betriebssystem wie Unix musst du die Optionsdatei in deinem Home-Verzeichnis schützen, damit andere Benutzer sie nicht lesen und herausfinden können, wie du dich mit deinem Konto mit MySQL verbinden kannst. Verwende chmod, um die Datei privat zu machen, indem du ihren Modus so einstellst, dass nur du darauf zugreifen kannst. Das kannst du mit einem der folgenden Befehle erreichen:

$ chmod 600 .my.cnf
$ chmod go-rwx .my.cnf

Unter Windows kannst du den Windows Explorer verwenden, um Dateiberechtigungen festzulegen.

1.5 Interaktives Ausführen von SQL-Anweisungen

Problem

Du hast mysql gestartet. Jetzt möchtest du SQL-Anweisungen an den MySQL-Server senden, damit sie ausgeführt werden.

Lösung

Gib sie einfach ein und teile mysql mit, wo jeder einzelne endet. Alternativ kannst du Einzeiler auch direkt in der Befehlszeile eingeben.

Diskussion

Wenn du mysql aufrufst, zeigt standardmäßig eine mysql> Eingabeaufforderung an, um dir mitzuteilen, dass es bereit für Eingaben ist. Um eine SQL-Anweisung an der Eingabeaufforderung mysql> auszuführen, gibst du sie ein, fügst am Ende ein Semikolon (;) hinzu, um das Ende der Anweisung zu kennzeichnen, und drückst Enter. Ein expliziter Anweisungsabschluss ist notwendig; mysqlinterpretiert Enter nicht als Abschluss, weil du eine Anweisung über mehrere Eingabezeilen eingeben kannst. Das Semikolon ist das gebräuchlichste Abschlusszeichen, aber du kannst auch \g(go) als Synonym für das Semikolon verwenden. Die folgenden Beispiele sind also gleichwertige Möglichkeiten, die gleiche Anweisung zu geben, auch wenn sie unterschiedlich eingegeben und beendet werden:

mysql> SELECT NOW();
+---------------------+
| NOW()               |
+---------------------+
| 2014-04-06 17:43:52 |
+---------------------+
mysql> SELECT
    -> NOW()\g
+---------------------+
| NOW()               |
+---------------------+
| 2014-04-06 17:43:57 |
+---------------------+

Bei der zweiten Anweisung ändert mysqldie Eingabeaufforderung von mysql> in ->, um dir mitzuteilen, dass es noch auf den Terminator der Anweisung wartet.

Die Anweisungstermini ; und \g sind nicht Teil der Anweisung selbst. Sie sind Konventionen, die vom Programm mysql verwendet werden. Es erkennt diese Terminatoren und entfernt sie aus der Eingabe, bevor es die Anweisung an den MySQL-Server sendet.

Einige Anweisungen erzeugen Ausgabezeilen, die so lang sind, dass sie mehr als eine Zeile auf deinem Terminal einnehmen, was die Abfrageergebnisse schwer lesbar machen kann. Um dieses Problem zu vermeiden, erzeugst du eine vertikale Ausgabe, indem du die Anweisung mit \G beendest und nicht mit ; oder \g. Die Ausgabe zeigt die Spaltenwerte in separaten Zeilen an:

mysql>  USE cookbook
mysql> SHOW FULL COLUMNS FROM limbs LIKE 'thing'\G
*************************** 1. row ***************************
     Field: thing
      Type: varchar(20)
 Collation: utf8mb4_0900_ai_ci
      Null: YES
       Key:
   Default: NULL
     Extra:
Privileges: select,insert,update,references
   Comment:

Um eine vertikale Ausgabe für alle in einer Sitzung ausgeführten Anweisungen zu erhalten, rufe mysql mit der Option -E (oder --vertical) auf. Um nur dieErgebnisse, die die Breite deines Terminals überschreiten, vertikal auszugeben, verwende --auto-vertical-output.

Um eine Anweisung direkt in der Befehlszeile auszuführen, gibst du sie mit der Option -e (oder --execute) an. Dies ist nützlich für Einzeiler. Um zum Beispiel die Zeilen in der Tabelle limbs zu zählen, verwendest du diesen Befehl:

$ mysql -e "SELECT COUNT(*) FROM limbs" cookbook
+----------+
| COUNT(*) |
+----------+
|       11 |
+----------+

Um mehrere Anweisungen auszuführen, trennst du sie mit einem Semikolon:

$ mysql -e "SELECT COUNT(*) FROM limbs;SELECT NOW()" cookbook
+----------+
| COUNT(*) |
+----------+
|       11 |
+----------+
+---------------------+
| NOW()               |
+---------------------+
| 2014-04-06 17:43:57 |
+---------------------+

mysql kann auch Anweisungen aus einer Datei oder aus einem anderen Programm lesen (siehe Rezept 1.6).

1.6 Ausführen von SQL-Anweisungen, die aus einer Datei oder einem Programm gelesen wurden

Problem

Du möchtest, dass mysql Anweisungen liest, die in einer Datei gespeichert sind, damit du sie nicht manuell eingeben musst. Oder du möchtest, dass mysql die Ausgabe eines anderen Programms liest.

Lösung

Um eine Datei zu lesen, leite die Eingabe von mysqlum oder verwende den Befehl source. Um aus einem Programm zu lesen, verwende eine Pipe.

Diskussion

Standardmäßig liest das Programm mysql Eingaben interaktiv über das Terminal, aber du kannst es auch mit anderen Eingabequellen wie einer Datei oder einem Programm füttern.

Zu diesem Zweck unterstützt MySQL den Batch-Modus, der sich eignet, um eine Reihe von Anweisungen wiederholt auszuführen, ohne sie jedes Mal manuell einzugeben. Der Batch-Modus macht es einfach, cron Aufträge einzurichten, die ohne Benutzereingriff ausgeführt werden.

Um ein SQL-Skript für mysql zu erstellen, das im Batch-Modus ausgeführt werden soll, schreibst du deine Anweisungen in eine Textdatei. Dann rufst du mysql auf und leitest die Eingabe so um, dass sie aus dieserDatei gelesen wird:

$ mysql cookbook < file_name

Aus einer Eingabedatei gelesene Anweisungen ersetzen das, was du normalerweise interaktiv von Hand eingeben würdest. Sie müssen also mit ;, \g oder \G abgeschlossen werden, genau wie bei der manuellen Eingabe. Der interaktive und der Batch-Modus unterscheiden sich im Standard-Ausgabeformat. Im interaktiven Modus wird standardmäßig das Tabellenformat (Kastenformat) verwendet. Im Stapelverarbeitungsmodus ist die Vorgabe das tabulatorgetrennte Format. Um die Standardeinstellung zu ändern, verwende die entsprechende Befehlsoption (siehe Rezept 1.7).

SQL-Skripte sind auch nützlich, um eine Reihe von SQL-Anweisungen an andere Personen zu verteilen. Das ist auch die Art und Weise, wie wir die SQL-Beispiele in diesem Buch weitergeben. Viele der hier gezeigten Beispiele können mit Hilfe von Skriptdateien ausgeführt werden, die in der begleitenden recipes Distribution enthalten sind (siehe Vorwort). Füttere mysql mit diesen Dateien im Batch-Modus, damit du die Anweisungen nicht selbst eintippen musst. Wenn ein Rezept zum Beispiel eine CREATE TABLE Anweisung enthält, die eine Tabelle definiert, findest du in der Regel eine SQL-Batch-Datei in der recipes Distribution, mit der du die Tabelle erstellen (und vielleicht Daten in sie laden) kannst. Erinnere dich daran, dass Rezept 1.2 die Anweisungen zum Erstellen und Auffüllen der Tabelle limbs zeigt. Diese Anweisungen wurden so gezeigt, wie du sie manuell eingeben würdest, aber das Tabellenverzeichnis der recipes Distribution enthält eine limbs.sql Datei, die Anweisungen enthält, die das Gleiche tun. Die Datei sieht wie folgt aus:

DROP TABLE IF EXISTS limbs;
CREATE TABLE limbs
(
  thing VARCHAR(20),  # what the thing is
  legs  INT,          # number of legs it has
  arms  INT,          # number of arms it has
  PRIMARY KEY(thing)
);

INSERT INTO limbs (thing,legs,arms) VALUES('human',2,2);
INSERT INTO limbs (thing,legs,arms) VALUES('insect',6,0);
INSERT INTO limbs (thing,legs,arms) VALUES('squid',0,10);
INSERT INTO limbs (thing,legs,arms) VALUES('fish',0,0);
INSERT INTO limbs (thing,legs,arms) VALUES('centipede',99,0);
INSERT INTO limbs (thing,legs,arms) VALUES('table',4,0);
INSERT INTO limbs (thing,legs,arms) VALUES('armchair',4,2);
INSERT INTO limbs (thing,legs,arms) VALUES('phonograph',0,1);
INSERT INTO limbs (thing,legs,arms) VALUES('tripod',3,0);
INSERT INTO limbs (thing,legs,arms) VALUES('Peg Leg Pete',1,2);
INSERT INTO limbs (thing,legs,arms) VALUES('space alien',NULL,NULL);

Um die Anweisungen in dieser SQL-Skriptdatei auszuführen, wechselst du vonin das Tabellenverzeichnis der recipes Distribution und führst diesenBefehl aus:

$ mysql cookbook < limbs.sql

Du wirst feststellen, dass das Skript eine Anweisung enthält, um die Tabelle zu löschen, falls sie bereits existiert, bevor du die Tabelle neu erstellst und mit Daten lädst. So kannst du mit der Tabelle experimentieren, vielleicht Änderungen vornehmen und sicher sein, dass du den Ausgangszustand jederzeit wiederherstellen kannst, indem du das Skript erneut ausführst.

Der soeben gezeigte Befehl veranschaulicht, wie man eine Eingabedatei für mysql auf der Befehlszeile angibt. Um eine Datei mit SQL-Anweisungen aus einer mysql -Sitzung heraus zu lesen, können Sie alternativ einen source filename Befehl (oder \.filename, was ein Synonym ist):

mysql> source limbs.sql
mysql> \. limbs.sql

SQL-Skripte können selbst source oder \. Befehle enthalten, um andere Skripte einzubinden. Das gibt dir zusätzliche Flexibilität, aber achte darauf, Schleifen zu vermeiden.

Eine Datei, die von mysql gelesen werden soll, muss nicht von Hand geschrieben werden; sie kann auch von einem Programm erstellt werden. Das Dienstprogramm mysqldump beispielsweise erstellt Datenbanksicherungen, indem es eine Reihe von SQL-Anweisungen schreibt, die die Datenbank neu erstellen. Um die Ausgabe von mysqldump neu zu laden, fütterst du sie mitan mysql. Du kannst zum Beispiel eine Datenbank wie folgt über das Netzwerk auf einen anderen MySQL-Server kopieren:

$ mysqldump cookbook > dump.sql
$ mysql -h other-host.example.com cookbook < dump.sql

mysql kann auch eine Pipe lesen, so dassdie Ausgaben anderer Programme als Eingabe verwenden kann. Jeder Befehl, der Ausgaben erzeugt, die aus korrekt beendeten SQL-Anweisungen bestehen, kann als Eingabequelle für mysql verwendet werden. Das Dump-and-Reload-Beispiel kann so umgeschrieben werden, dass die beiden Programme direkt über eine Pipe miteinander verbunden werden, ohne dass eine Zwischendatei benötigt wird:

$ mysqldump cookbook | mysql -h other-host.example.com cookbook

Programm-generiertes SQL kann auch nützlich sein, um eine Tabelle mit Testdaten zu füllen, ohne die INSERT Anweisungen von Hand zu schreiben. Erstelle ein Programm, das die Anweisungen generiert, und sende die Ausgabe über eine Pipe an mysql:

$ generate-test-data | mysql cookbook

InRezept 6.6 wird mysqldump näher erläutert.

1.7 Ziel und Format der mysql-Ausgabe steuern

Problem

Du möchtest, dass die Ausgabe von mysql irgendwo anders als auf deinem Bildschirm landet. Und du willst nicht unbedingt das Standard-Ausgabeformat haben.

Lösung

Leite die Ausgabe in eine Datei um oder verwende eine Pipe, um die Ausgabe an ein Programm zu senden. Du kannst auch andere Aspekte der Ausgabe von mysql steuern, um tabellarische, tabellengetrennte, HTML- oder XML-Ausgaben zu erzeugen, Spaltenüberschriften zu unterdrücken oder mysql mehr oder weniger ausführlich zu gestalten.

Diskussion

Wenn du die Ausgabe von mysql nicht an eine andere Stelle sendest, wird sie auf deinem Bildschirm angezeigt. Um die Ausgabe von mysql in einer Datei zu speichern, verwende die Umleitungsfunktion deiner Shell:

$ mysql cookbook > outputfile

Wenn du mysql interaktiv mit umgeleiteter Ausgabe ausführst, kannst du nicht sehen, was du eintippst, also liest du in diesem Fall normalerweise auch die Eingabe aus einer Datei (oder einem anderen Programm):

$ mysql cookbook < inputfile > outputfile

Um die Ausgabe an ein anderes Programm zu senden (zum Beispiel, um dieAusgabe der Abfrage zu parsen), verwende eine Pipe:

$ mysql cookbook < inputfile | sed -e "s/\t/:/g" > outputfile

Der Rest dieses Abschnitts zeigt, wie du das Ausgabeformat mysql steuern kannst.

Tabellarische oder tabulatorgetrennte Ausgabe erzeugen

mysql wählt sein Standard-Ausgabeformat danach aus, ob es interaktiv oder nicht interaktiv ausgeführt wird. Bei interaktiver Nutzung schreibt mysql die Ausgabe im Tabellenformat (Boxed) auf das Terminal:

$ mysql cookbook
mysql> SELECT * FROM limbs WHERE legs=0;
+------------+------+------+
| thing      | legs | arms |
+------------+------+------+
| squid      |    0 |   10 |
| fish       |    0 |    0 |
| phonograph |    0 |    1 |
+------------+------+------+
3 rows in set (0.00 sec)

Bei nicht-interaktiver Verwendung (wenn die Eingabe oder Ausgabe umgeleitet wird) schreibt mysql eine tabulatorgetrennte Ausgabe:

$ echo "SELECT * FROM limbs WHERE legs=0" | mysql cookbook
thing   legs    arms
squid   0       10
fish    0       0
phonograph      0       1

Um das Standardausgabeformat zu überschreiben, verwende die entsprechende Befehlsoption. Betrachte den oben gezeigten Befehl sed und ändere seine Parameter, um die Ausgabe zu verschleiern:

$ mysql cookbook < inputfile | sed -e "s/table/XXXXX/g" 
$ mysql cookbook -e "SELECT * FROM limbs where legs=4" | ↩
        sed -e "s/table/XXXXX/g"
 thing legs arms 
 XXXXX 4 0 
 armchair 4 2

Da mysql in diesem Kontext nicht interaktiv ausgeführt wird, erzeugt es tabulatorgetrennte Ausgaben, die schwieriger zu lesen sein können als tabellarische Ausgaben. Verwende die Option -t (oder--table ), um eine besser lesbare tabellarische Ausgabe zu erzeugen:

$ mysql cookbook -t -e "SELECT * FROM limbs where legs=4" | ↩
        sed -e "s/table/XXXXX/g"

+----------+------+------+
| thing    | legs | arms |
+----------+------+------+
| XXXXX    |    4 |    0 |
| armchair |    4 |    2 |
+----------+------+------+

Umgekehrt kannst du im interaktiven Modus eine (tabulatorgetrennte) Batch-Ausgabeerzeugen. Verwende dazu -B (oder --batch).

HTML- oder XML-Ausgabe produzieren

mysql erzeugt eine HTML-Tabelle aus jeder Abfrageergebnismenge, wenn du die Option -H (oder --html) verwendest. So kannst du ganz einfach eine Ausgabe erstellen, die du in eine Webseite einbinden kannst, die ein Abfrageergebnis anzeigt. Hier ist ein Beispiel (mit Zeilenumbrüchen, um die Ausgabe leichter lesbar zu machen):

$ mysql -H -e "SELECT * FROM limbs WHERE legs=0" cookbook
<TABLE BORDER=1>
<TR><TH>thing</TH><TH>legs</TH><TH>arms</TH></TR>
<TR><TD>squid</TD><TD>0</TD><TD>10</TD></TR>
<TR><TD>fish</TD><TD>0</TD><TD>0</TD></TR>
<TR><TD>phonograph</TD><TD>0</TD><TD>1</TD></TR>
</TABLE>

Die erste Zeile der Tabelle enthält Spaltenüberschriften. Wenn du keine Kopfzeile möchtest, findest du im nächsten Abschnitt Anweisungen.

Du kannst die Ausgabe in einer Datei speichern und sie dann mit einem Webbrowser ansehen. Unter Mac OS X kannst du das zum Beispiel so machen:

$ mysql -H -e "SELECT * FROM limbs WHERE legs=0" cookbook > limbs.html
$ open -a safari limbs.html

Um ein XML-Dokument anstelle von HTML zu erzeugen, verwende die Option -X (oder --xml):

$ mysql -X -e "SELECT * FROM limbs WHERE legs=0" cookbook
<?xml version="1.0"?>

<resultset statement="select * from limbs where legs=0
">
  <row>
    <field name="thing">squid</field>
    <field name="legs">0</field>
    <field name="arms">10</field>
  </row>

  <row>
    <field name="thing">fish</field>
    <field name="legs">0</field>
    <field name="arms">0</field>
  </row>

  <row>
    <field name="thing">phonograph</field>
    <field name="legs">0</field>
    <field name="arms">1</field>
  </row>
</resultset>

Du kannst XML für eine Vielzahl von Zwecken umformatieren, indem du es durch XSLT-Transformationen laufen lässt. So kannst du dieselbe Eingabe verwenden, um viele verschiedene Ausgabeformate zu erzeugen.

Die Optionen -H, --html-X und --xml erzeugen nur Ausgaben für Anweisungen, die eine Ergebnismenge erzeugen, nicht aber für Anweisungen wie INSERT oder UPDATE.

Um deine eigenen Programme zu schreiben, die XML aus Abfrageergebnissen generieren, siehe Rezept 13.15.

Spaltenüberschriften in der Abfrageausgabe unterdrücken

Das tabulatorgetrennte Format ist praktisch, um Datendateien für den Import in andere Programme zu erstellen. Allerdings werden in der ersten Zeile der Ausgabe für jede Abfrage standardmäßig die Spaltenüberschriften aufgeführt, was vielleicht nicht immer das ist, was du willst. Angenommen, ein Programm namens summarize erstellt deskriptive Statistiken für eine Zahlenspalte. Wenn du die Ausgabe von mysql für dieses Programm erstellst, würde eine Zeile mit Spaltenüberschriften die Ergebnisse verfälschen, da summarize sie als Daten behandeln würde. Um eine Ausgabe zu erstellen, die nur Datenwerte enthält, unterdrückst du die Kopfzeile mit der Option --skip-column-names:

$ mysql --skip-column-names -e "SELECT arms FROM limbs" cookbook | summarize

Wenn du die Silent-Option (-soder --silent) zweimal angibst, hast du denselben Effekt:

$ mysql -ss -e "SELECT arms FROM limbs" cookbook | summarize

Festlegen des Trennzeichens für die Ausgabespalten

Im nicht-interaktiven Modus trennt mysqldie Ausgabespalten durch Tabulatoren, und es gibt keine Option zur Angabe des Ausgabetrennzeichens. Um eine Ausgabe zu erzeugen, die ein anderes Trennzeichen verwendet, musst du die Ausgabe von mysql nachbearbeiten. Angenommen, du möchtest eine Ausgabedatei für ein Programm erstellen, das erwartet, dass die Werte durch Doppelpunkte (:) und nicht durch Tabulatoren getrennt werden. Unter Unix kannst du Tabulatoren in beliebige Begrenzungszeichen umwandeln, indem du ein Dienstprogramm wie tr oder sed verwendest. Jeder der folgenden Befehle wandelt Tabulatoren in Doppelpunkte um (TAB zeigt an, wo du ein Tabulatorzeichen eintippst):

$ mysql cookbook < inputfile  | sed -e "s/TAB/:/g" > outputfile
$ mysql cookbook < inputfile  | tr "TAB" ":" > outputfile
$ mysql cookbook < inputfile  | tr "\011" ":" > outputfile

Die Syntax unterscheidet sich von Version zu Version von tr; konsultiere deine lokale Dokumentation. Außerdem verwenden einige Shells das Tabulatorzeichen für spezielle Zwecke wie die Vervollständigung von Dateinamen. In solchen Shells gibst du ein Tabulatorzeichen in den Befehl ein, indem du Strg-V vorangibst.

sed ist leistungsfähiger als tr, weil es reguläre Ausdrücke versteht und mehrere Ersetzungen zulässt. Das ist nützlich für , das z. B. das CSV-Format (Comma-Separated Values) ausgibt, das drei Ersetzungen erfordert:

  1. Entferne alle Anführungszeichen, die in den Daten vorkommen, indem du sie verdoppelst, damit sie nicht als Spaltentrennzeichen interpretiert werden, wenn du die resultierende CSV-Datei verwendest.

  2. Ändere die Tabulatoren in Kommas.

  3. Umfasse die Spaltenwerte mit Anführungszeichen.

sed können alle drei Ersetzungen in einer einzigen Befehlszeile durchgeführt werden:

$ mysql cookbook < inputfile \
    | sed -e 's/"/""/g' -e 's/TAB/","/g' -e 's/^/"/' -e 's/$/"/' > outputfile

Das ist, gelinde gesagt, kryptisch. Du kannst das gleiche Ergebnis mit anderen Sprachen erzielen, die vielleicht einfacher zu lesen sind. Hier ist ein kurzes Perl-Skript, das dasselbe tut wie der Befehl sed (es wandelt tabulatorgetrennte Eingaben in CSV-Ausgaben um) und enthält Kommentare, um zu dokumentieren, wie es funktioniert:

#!/usr/bin/perl
# csv.pl: convert tab-delimited input to comma-separated values output
while (<>)        # read next input line
{
  s/"/""/g;       # double quotes within column values
  s/\t/","/g;     # put "," between column values
  s/^/"/;         # add " before the first value
  s/$/"/;         # add " after the last value
  print;          # print the result
}

Wenn du das Skript csv.pl nennst, benutze es wie folgt:

$ mysql cookbook < inputfile  | perl csv.pl > outputfile

tr und sed sind unter Windows normalerweise nicht verfügbar. Perl ist als plattformübergreifende Lösung möglicherweise besser geeignet, da es sowohl unter Unix als auch unter Windows läuft. (Auf Unix-Systemen ist Perl normalerweise vorinstalliert. Unter Windows kannst du es frei installieren.)

Eine andere Möglichkeit, CSV-Ausgaben zu erzeugen, ist die Verwendung des Perl-Moduls Text::CSV_XS, das für diesen Zweck entwickelt wurde. Das Dienstprogramm cvt_file.pl, das in der Rezepte-Distribution enthalten ist, verwendet dieses Modul, um einen universellen Dateireformer zu erstellen.

Den Verbosity-Level von mysql kontrollieren

Wenn du mysqlnicht interaktiv ausführst, ändert sich nicht nur das Standardausgabeformat, sondern es wird auch knapper. mysql gibt zum Beispiel keine Zeilenzahlen aus und zeigt auch nicht an, wie lange die Ausführung der Anweisungen gedauert hat. Um mysql zu veranlassen, ausführlicher zu sein, verwende -v (oder --verbose) und gib die Option mehrmals an, um die Ausführlichkeit zu erhöhen. Probiere die folgenden Befehle aus, um zu sehen, wie sich die Ausgabe unterscheidet:

$ echo "SELECT NOW()" | mysql
$ echo "SELECT NOW()" | mysql -v
$ echo "SELECT NOW()" | mysql -vv
$ echo "SELECT NOW()" | mysql -vvv

Die Gegenstücke zu -v und--verbose sind -s und --silent, die ebenfalls mehrfach verwendet werden können, um die Wirkung zu erhöhen.

1.8 Benutzerdefinierte Variablen in SQL-Anweisungen verwenden

Problem

Du möchtest in einer Anweisung einen Wert verwenden, der durch eine frühere Anweisung erzeugt wurde.

Lösung

Speichere den Wert in einer benutzerdefinierten Variablen, um ihn für eine spätere Verwendung zu speichern.

Diskussion

Um einen von einer SELECT Anweisung zurückgegebenen Wert zu speichern, weise ihn einer benutzerdefinierten Variablen zu. So kannst du später in anderen Anweisungen in derselben Sitzung darauf verweisen (aber nicht sitzungsübergreifend ). Benutzervariablen sind eine MySQL-spezifische Erweiterung von Standard-SQL. Sie funktionieren nicht mit anderen Datenbank-Engines.

Um einer Benutzervariablen innerhalb einer SELECT Anweisung einen Wert zuzuweisen, verwendest du @var_name :=value Die Variable kann in nachfolgenden Anweisungen überall dort verwendet werden, wo ein Ausdruckerlaubt ist, z. B. in einer WHERE Klausel oder in einer INSERT Anweisung.

Hier ist ein Beispiel, das einer Benutzervariablen einen Wert zuweist und später auf diese Variable verweist. Dies ist eine einfache Methode, um einen Wert zu bestimmen, der eine Zeile in einer Tabelle charakterisiert, und dann diese bestimmte Zeile auszuwählen:

mysql> SELECT MAX(arms+legs) INTO @max_limbs FROM limbs;
Query OK, 1 row affected (0,01 sec)
mysql> SELECT * FROM limbs WHERE arms+legs = @max_limbs;
+-----------+------+------+
| thing     | legs | arms |
+-----------+------+------+
| centipede |   99 |    0 |
+-----------+------+------+

Eine andere Verwendung für eine Variable ist das Speichern des Ergebnisses von LAST_INSERT_ID() nach dem Erstellen einer neuen Zeile in einer Tabelle, die eine AUTO_INCREMENT Spalte hat:

mysql> SELECT @last_id := LAST_INSERT_ID();

LAST_INSERT_ID() gibt den letzten Wert von AUTO_INCREMENT zurück. Wenn du ihn in einer Variablen speicherst, kannst du dich in nachfolgenden Anweisungen mehrmals auf den Wert beziehen, auch wenn du andere Anweisungen gibst, die ihre eigenen AUTO_INCREMENT Werte erzeugen und damit den von LAST_INSERT_ID() zurückgegebenen Wert ändern. In Rezept 15.10 wird diese Technik näher erläutert .

Benutzervariablen enthalten einzelne Werte. Wenn eine Anweisung mehrere Zeilen zurückgibt, schlägt die Anweisung mit einem Fehler fehl, aber der Wert aus der ersten Zeile wird zugewiesen:

mysql> SELECT thing FROM limbs WHERE legs = 0;
+------------+
| thing      |
+------------+
| squid      |
| fish       |
| phonograph |
+------------+
3 rows in set (0,00 sec)

mysql> SELECT thing INTO @name FROM limbs WHERE legs = 0;
ERROR 1172 (42000): Result consisted of more than one row
mysql> SELECT @name;
+-------+
| @name |
+-------+
| squid |
+-------+

Wenn die Anweisung keine Zeilen liefert, findet keine Zuweisung statt und die Variable behält ihren vorherigen Wert. Wenn die Variable zuvor nicht verwendet wurde, ist ihr Wert NULL:

mysql> SELECT thing INTO @name2 FROM limbs WHERE legs < 0;
Query OK, 0 rows affected, 1 warning (0,00 sec)

mysql> SHOW WARNINGS;
+---------+------+-----------------------------------------------------+
| Level   | Code | Message                                             |
+---------+------+-----------------------------------------------------+
| Warning | 1329 | No data - zero rows fetched, selected, or processed |
+---------+------+-----------------------------------------------------+
1 row in set (0,00 sec)

mysql> select @name2;
+--------+
| @name2 |
+--------+
| NULL   |
+--------+
1 row in set (0,00 sec)
Tipp

Der SQL-Befehl SHOW WARNINGS gibt Informationsmeldungen zu behebbaren Fehlern zurück, wie z.B. die Zuweisung eines leeren Ergebnisses an eine Variable oder die Verwendung eines veralteten Features.

Um eine Variable explizit auf einen bestimmten Wert zu setzen, verwendest du eine SET Anweisung. Die SET Syntax kann entweder := oder = als Zuweisungsoperator verwenden:

mysql> SET @sum = 4 + 7;
mysql> SELECT @sum;
+------+
| @sum |
+------+
|   11 |
+------+

Du kannst ein SELECT Ergebnis einer Variablen zuweisen, vorausgesetzt, du schreibst es als skalare Subquery (eine Abfrage in Klammern, die einen einzelnen Wert zurückgibt):

mysql> SET @max_limbs = (SELECT MAX(arms+legs) FROM limbs);

Bei den Namen von Benutzervariablen wird nicht zwischen Groß- und Kleinschreibung unterschieden:

mysql> SET @x = 1, @X = 2; SELECT @x, @X;
+------+------+
| @x   | @X   |
+------+------+
| 2    | 2    |
+------+------+

Benutzervariablen können nur dort vorkommen, wo Ausdrücke erlaubt sind,nicht dort, wo Konstanten oder literale Bezeichner angegeben werden müssen. Es ist verlockend, Variablen für Dinge wie Tabellennamen zu verwenden, aber das funktioniert nicht. Wenn du zum Beispiel versuchst, einen temporären Tabellennamen mit einer Variablen wie folgt zu erzeugen, schlägt das fehl:

mysql> SET @tbl_name = CONCAT('tmp_tbl_', CONNECTION_ID());
mysql> CREATE TABLE @tbl_name (int_col INT);
ERROR 1064 (42000): You have an error in your SQL syntax; ↩
check the manual that corresponds to your MySQL server version for ↩
the right syntax to use near '@tbl_name (int_col INT)' at line 1

Du kannst jedoch eine vorbereitete SQL-Anweisung erstellen, die @tbl_name enthält, und dann das Ergebnis ausführen. Rezept 6.4 zeigt, wie das geht.

SET wird auch verwendet, um gespeicherten Programmparametern, lokalen Variablen und Systemvariablen Werte zuzuweisen. Beispiele findest du in Kapitel 11 und Rezept 22.1.

1.9 Anpassen einer Eingabeaufforderung für mysql

Problem

Du hast mehrere Verbindungen in verschiedenen Terminalfenstern geöffnet und möchtest sie visuell unterscheiden.

Lösung

Setze eine Eingabeaufforderung mysql auf einen benutzerdefinierten Wert.

Diskussion

Du kannst die Eingabeaufforderung mysql anpassen, indem du beim Start die Option --prompt angibst: 

$ mysql --prompt="MySQL Cookbook> "
MySQL Cookbook>

Wenn der Client bereits gestartet wurde, kannst du den Befehlprompt verwenden, um ihn interaktiv zu ändern: 

mysql> prompt MySQL Cookbook> 
PROMPT set to 'MySQL Cookbook> '
MySQL Cookbook>

Der Befehl prompt unterstützt, wie auch die anderen mysql Befehle, eine Kurzversion: \R: 

mysql> \R MySQL Cookbook> 
PROMPT set to 'MySQL Cookbook> '
MySQL Cookbook>

Um den Wert der Eingabeaufforderung in der Konfigurationsdatei festzulegen, füge die Optionprompt unter dem Abschnitt [mysql] ein: 

[mysql]
prompt="MySQL Cookbook> "

Anführungszeichen sind optional und werden nur benötigt, wenn du Sonderzeichen haben möchtest, wie z.B. ein Leerzeichen am Ende der Eingabeaufforderung.

Schließlich kannst du eine Eingabeaufforderung mit der UmgebungsvariablenMYSQL_PS1 festlegen: 

$ export MYSQL_PS1="MySQL Cookbook> "
$ mysql
MySQL Cookbook>

Um eine Eingabeaufforderung auf ihren Standardwert zurückzusetzen, führe den Befehl prompt ohne Argumente aus: 

MySQL Cookbook> prompt
Returning to default PROMPT of mysql> 
mysql>
Tipp

Wenn du die Umgebungsvariable MYSQL_PS1verwendet hast, ist die Eingabeaufforderung standardmäßig der Wert der Variable MYSQL_PS1 anstelle von mysql.

Die Eingabeaufforderung mysql ist in hohem Maße anpassbar. Du kannst sie so einstellen, dass sie das aktuelle Datum, die Uhrzeit, das Benutzerkonto, die Standarddatenbank, den Server-Host und andere Informationen über deine Datenbank Verbindung anzeigt. Die vollständige Liste der unterstützten Optionen findest du im MySQL User Reference Manual.

Um ein Benutzerkonto in der Eingabeaufforderung zu haben, benutze entweder die spezielle Sequenz \u , um nur einen Benutzernamen anzuzeigen, oder \U, um das komplette Benutzerkonto anzuzeigen: 

mysql> prompt \U> 
PROMPT set to '\U> '
cbuser@localhost>

Wenn du dich mit MySQL-Servern auf verschiedenen Rechnern verbindest, möchtest du vielleicht, dassden Hostnamen des MySQL-Servers in der Eingabeaufforderung anzeigt. Dafür gibt es eine spezielle Sequenz, \h, die du verwenden kannst: 

mysql> \R \h> 
PROMPT set to '\h> '
Delly-7390>

Um die aktuelle Standarddatenbank in der Eingabeaufforderung zu haben, verwendest du die spezielle Sequenz \d : 

mysql> \R \d> 
PROMPT set to '\d> '
(none)> use cookbook
Database changed
cookbook>

mysql unterstützt mehrere Optionenum die Zeit in die Eingabeaufforderung einzubeziehen. Du kannst das komplette Datum und die Uhrzeit angeben oder nur einen Teil davon: 

mysql> prompt \R:\m:\s> 
PROMPT set to '\R:\m:\s> '
15:30:10>
15:30:10> prompt \D> 
PROMPT set to '\D> '
Sat Sep 19 15:31:19 2020>

Warnung

Du kannst den aktuellen Tag des Monats nur angeben, wenn du das vollständige aktuelle Datum verwendest. Dies wurde unter MySQL Bug #72071gemeldet und ist immer noch nicht behoben.

Spezielle Sequenzen können miteinander und mit jedem anderen Text kombiniert werden, mysql verwendet den UTF-8-Zeichensatz, und wenn dein Terminal ebenfalls UTF-8 unterstützt, kannst du Smiley-Zeichen verwenden, um deine Eingabeaufforderung eindrucksvoller zu gestalten. Um zum Beispiel Informationen über das verbundene Benutzerkonto, den MySQL-Host, die Standarddatenbank und die aktuelle Uhrzeit zur Hand zu haben, kannst du die Eingabeaufforderung auf \u@\h [📁\d] (🕑\R:\m:\s)> setzen: 

mysql> prompt \u@\h [📁\d] (🕑\R:\m:\s)> 
PROMPT set to '\u@\h [📁\d] (🕑\R:\m:\s)> '
cbuser@Delly-7390 [📁cookbook] (🕑16:15:41)>

1.10 Externe Programme verwenden

Problem

Du möchtest ein externes Programm verwenden, ohne die Eingabeaufforderung mysql client command zu verlassen.

Lösung

Verwende den Befehl system, um ein Programm aufzurufen.

Diskussion

MySQL erlaubt es dir zwar, zufällige Passwörter für seine eigenen internen Benutzerkonten zu generieren, hat aber noch keine interne Funktion, um ein sicheres Benutzerpasswort für alle anderen Fälle zu erzeugen. Führe den Befehl system aus, um eines der Tools des Betriebssystems zu verwenden: 

mysql> system openssl rand -base64 16
p1+iSG9rveeKc6v0+lFUHA==

\! ist eine kurze Version des system Befehls: 

mysql> \! pwgen -synBC 16 1
Nu=3dWvrH7o_tWiE

pwgen ist möglicherweise nicht auf deinem Betriebssystem installiert. Bevor du dieses Beispiel ausführst, musst du das Paket pwgen installieren.

system ist ein Befehl des mysql Clients und wird lokal mit den Rechten des Clients ausgeführt. Standardmäßig wird der MySQL-Server als Benutzer mysql ausgeführt, du kannst dich aber mit einem beliebigen Benutzerkonto anmelden. In diesem Fall kannst du nur auf die Programme und Dateien zugreifen, die für dein Betriebssystemkonto zugelassen sind. Normale Benutzer können also nicht auf das Datenverzeichniszugreifen, das dem speziellen Benutzer mysqld gehört, unter dem der Prozess läuft: 

mysql> select @@datadir;
+-----------------+
| @@datadir       |
+-----------------+
| /var/lib/mysql/ |
+-----------------+
1 row in set (0,00 sec)

mysql> system ls /var/lib/mysql/
ls: cannot open directory '/var/lib/mysql/': Permission denied
mysql> \! id
uid=1000(sveta) gid=1000(sveta) groups=1000(sveta)

Aus demselben Grund führt systemkeine Befehle auf dem entfernten Server aus.

Du kannst jedes Programm verwenden, Optionen angeben, die Ausgabe umleiten und sie an andere Befehle weiterleiten. Einnützlicher Einblick, den dir das Betriebssystem geben kann, ist, wie viele physische Ressourcen vom mysqld Prozess belegt werden, und vergleicht ihn mit den Daten, die der MySQL-Server selbst intern sammelt.

MySQL speichert Informationen über Speichernutzung in der Performance Schema. Das zugehörige sys-Schema enthält Ansichten, mit denen du leicht auf diese Informationen zugreifen kannst. Insbesondere kannst du die Gesamtmenge des zugewiesenen Speichers in einem für Menschen lesbaren Format abfragen, indem du die sys.memory_global_total Ansicht: 

mysql> SELECT * FROM sys.memory_global_total;
+-----------------+
| total_allocated |
+-----------------+
| 253.90 MiB      |
+-----------------+
1 row in set (0.00 sec)

mysql> \! ps -o rss hp `pidof mysqld` | awk '{print $1/1024}'
298.66

Die Kette des Betriebssystems fordert Statistiken über die Nutzung des physischen Speichers vom Betriebssystem an und wandelt sie in ein für Menschen lesbares Format um. Dieses Beispiel zeigt, dass nicht der gesamte zugewiesene Speicher innerhalb des MySQL-Servers instrumentiert wird.

Beachte, dass du den mysql Client auf demselben Rechner wie deinen MySQL Server laufen lassen musst, damit dies funktioniert.

1.11 Filtern und Verarbeiten der Ausgabe

Warnung

Dieses Rezept funktioniert nur auf Unix-Plattformen!

Problem

Du möchtest das Ausgabeformat des MySQL-Clients über seine eingebauten Fähigkeiten hinaus ändern.

Lösung

Setze pager auf eine Kette von Befehlen und filtere die Ausgabe so, wie du es möchtest.

Diskussion

Manchmal erlauben es die Formatierungsmöglichkeiten des mysql Clients nicht, mit der Ergebnismenge zu arbeiten. Zum Beispiel könnte die Anzahl der zurückgegebenen Zeilen zu groß sein, um auf den Bildschirm zu passen. Oder die Anzahl der Spalten kann dazu führen, dass das Ergebnis zu breit ist, um es bequem auf dem Bildschirm zu lesen. Mit den Standard-Betriebssystem-Pagern, wie z. B. less oder more, kannst du bequemer mit langen und breiten Texten arbeiten.

Du kannst angeben, welcher Pager verwendet werden soll, indem du beim Starten des mysql Clients die Option --pager angibst oder indem du den Befehl pager und seine kürzere Version \P verwendest. Du kannst jedes Argument für den Pager angeben.

Um mysql anzuweisen, less als Pager zu verwenden, gibst du die Option --pager=less an oder gibst diesen Wert interaktiv ein. Gib die Konfigurationsparameter für den Befehl so an, wie du es in deiner Lieblingsshell tust. Im folgenden Beispiel haben wir die Optionen -F und -X angegeben, damit less beendet wird, wenn die Ergebnismenge klein genug ist, um auf den Bildschirm zu passen, und bei Bedarf normal funktioniert: 

mysql> pager less -F -X
PAGER set to 'less -F -X'
mysql> SELECT * FROM city;
+----------------+----------------+----------------+
| state          | capital        | largest        |
+----------------+----------------+----------------+
| Alabama        | Montgomery     | Birmingham     |
| Alaska         | Juneau         | Anchorage      |
| Arizona        | Phoenix        | Phoenix        |
| Arkansas       | Little Rock    | Little Rock    |
| California     | Sacramento     | Los Angeles    |
| Colorado       | Denver         | Denver         |
| Connecticut    | Hartford       | Bridgeport     |
| Delaware       | Dover          | Wilmington     |
| Florida        | Tallahassee    | Jacksonville   |
| Georgia        | Atlanta        | Atlanta        |
| Hawaii         | Honolulu       | Honolulu       |
| Idaho          | Boise          | Boise          |
| Illinois       | Springfield    | Chicago        |
| Indiana        | Indianapolis   | Indianapolis   |
| Iowa           | Des Moines     | Des Moines     |
| Kansas         | Topeka         | Wichita        |
| Kentucky       | Frankfort      | Louisville     |
:
mysql> SELECT * FROM movies;
+----+------+----------------------------+
| id | year | movie                      |
+----+------+----------------------------+
|  1 | 1997 | The Fifth Element          |
|  2 | 1999 | The Phantom Menace         |
|  3 | 2001 | The Fellowship of the Ring |
|  4 | 2005 | Kingdom of Heaven          |
|  5 | 2010 | Red                        |
|  6 | 2011 | Unknown                    |
+----+------+----------------------------+
6 rows in set (0,00 sec)

Du kannst pager nicht nur verwenden, um die Ausgabe zu verschönern, sondern auch, um jeden Befehl auszuführen, der Text verarbeiten kann. Eine häufige Anwendung ist die Suche nach einem Muster in den Daten, die von der Diagnoseanweisung gedruckt werden, mit grep. Wenn du z.B. nur History list length in der langen SHOW ENGINE INNODB STATUS Ausgabe sehen willst, benutze \P grep "History list length.". Sobald du mit der Suche fertig bist, setze den Pager mit dem leeren pagerBefehl zurück oder weise mysql an pager zu deaktivieren und mit nopager oder \n auf STDOUT zu drucken: 

mysql> \P grep "History list length"
PAGER set to 'grep "History list length"'
mysql> SHOW ENGINE INNODB STATUS\G
History list length 30
1 row in set (0,00 sec)

mysql> SELECT SLEEP(60);
1 row in set (1 min 0,00 sec)

mysql> SHOW ENGINE INNODB STATUS\G
History list length 37
1 row in set (0,00 sec)

mysql> nopager
PAGER set to stdout

Eine weitere nützliche Option bei der Diagnose ist das Senden der Ausgabe nirgendwo hin. Um zum Beispiel die Effektivität einer Abfrage zu messen, möchtest du vielleicht die Sitzungsstatusvariable Handler_* untersuchen. In diesem Fall interessierst du dich nicht für das Ergebnis der Abfrage, sondern nur für die Ausgabe des folgenden Diagnosebefehls. Es kann sogar sein, dass du Diagnosedaten an professionelle Datenbankberater senden möchtest, aber aus Sicherheitsgründen nicht willst, dass sie die tatsächliche Abfrageausgabe sehen.

In diesem Fall kannst du pager anweisen, eine Hash-Funktion zu verwenden oder die Ausgabe ins Leere zu schicken: 

mysql> pager md5sum
PAGER set to 'md5sum'
mysql> SELECT 'Output of this statement is a hash';
8d83fa642dbf6a2b7922bcf83bc1d861  -
1 row in set (0,00 sec)

mysql> pager cat > /dev/null
PAGER set to 'cat > /dev/null'
mysql> SELECT 'Output of this statement goes to nowhere';
1 row in set (0,00 sec)

mysql> pager
Default pager wasn't set, using stdout.
mysql> SELECT 'Output of this statement is visible';

+-------------------------------------+
| Output of this statement is visible |
+-------------------------------------+
| Output of this statement is visible |
+-------------------------------------+
1 row in set (0,00 sec)
Tipp

Um die Ausgabe einer Abfrage, Informationsmeldungen und alle Befehle, die du eingibst, in eine Datei umzuleiten, verwende pager cat > FILENAME. Um in eine Datei umzuleiten und die Ausgabe trotzdem zu sehen, verwende den Befehl tee und seine Kurzversion \T. Der integrierte Befehl tee funktioniert sowohl auf UNIX- als auch auf Windows-Plattformen.

Du kannst die Befehle von pagermithilfe von Pipes miteinander verknüpfen. Wenn du zum Beispiel den Inhalt der Tabelle limbs in verschiedenen Schriftarten ausdrucken willst, setze pager auf eine Kette von Aufrufen wie in der folgenden Liste:

  1. tr -d ' ' um zusätzliche Leerzeichen zu entfernen

  2. awk -F'|' '{print "+"$2"+\033[3m"$3"\033[0m+⁠\033[1m"$4"\033​[0m"$5"+"}' um dem Text Stile hinzuzufügen

  3. column -s '+' -t' für schön formatierte Ausgaben

mysql> \P tr -d ' ' | ↩
awk -F'|' '{print "+"$2"+\033[3m"$3"\033[0m+\033[1m"$4"\033[0m"$5"+"}' | ↩
column -s '+' -t
PAGER set to 'tr -d ' ' | ↩
awk -F'|' '{print "+"$2"+\033[3m"$3"\033[0m+\033[1m"$4"\033[0m"$5"+"}' | ↩
column -s '+' -t'
mysql> select * from limbs;
                  
thing       legs  arms
                  
human       2     2
insect      6     0
squid       0     10
fish        0     0
centipede   99    0
table       4     0
armchair    4     2
phonograph  0     1
tripod      3     0
PegLegPete  1     2
spacealien  NULL  NULL
                  
11 rows in set (0,00 sec)

Get MySQL Kochbuch, 4. Auflage now with the O’Reilly learning platform.

O’Reilly members experience books, live events, courses curated by job role, and more from O’Reilly and nearly 200 top publishers.

Start your free trial