Die Funktion BENCHMARK()
wiederholt die
Ausführung des Ausdrucks expr
mit der mit count
angegebenen
Häufigkeit. Sie kann verwendet werden, um zu ermitteln, wie
schnell MySQL den Ausdruck verarbeitet. Der Ergebniswert ist
immer 0
. Vorgesehen ist die Verwendung
dieser Funktion aus dem Client mysql
heraus. Dieser gibt dann die Ausführungszeiten der Abfrage
an:
mysql> SELECT BENCHMARK(1000000,ENCODE('hello','goodbye'));
+----------------------------------------------+
| BENCHMARK(1000000,ENCODE('hello','goodbye')) |
+----------------------------------------------+
| 0 |
+----------------------------------------------+
1 row in set (4.74 sec)
Die gemeldete Zeit ist die auf der Clientseite verstrichene
Zeit und nicht die Prozessorzeit auf der Serverseite. Wir
empfehlen die mehrfache Ausführung von
BENCHMARK()
und die Interpretation des
Ergebnisses im Hinblick darauf, wie hoch die Belastung des
Servercomputers ist.
Gibt den Zeichensatz des String-Arguments zurück.
mysql>SELECT CHARSET('abc');
-> 'latin1' mysql>SELECT CHARSET(CONVERT('abc' USING utf8));
-> 'utf8' mysql>SELECT CHARSET(USER());
-> 'utf8'
Gibt den Sortierfolgenvorrangswert des String-Arguments zurück.
mysql>SELECT COERCIBILITY('abc' COLLATE latin1_swedish_ci);
-> 0 mysql>SELECT COERCIBILITY(USER());
-> 3 mysql>SELECT COERCIBILITY('abc');
-> 4
Die Rückgabewerte haben die in der folgenden Tabelle aufgeführten Bedeutungen. Niedrigere Werte haben dabei eine höhere Rangstufe.
Sortierfolgenvorrang | Bedeutung | Beispiel |
0 |
Explizite Sortierung | Wert mit COLLATE -Klausel |
1 |
Keine Sortierung | Verkettung von Strings mit unterschiedlichen Sortierungen |
2 |
Implizite Sortierung | Spaltenwert, Parameter einer gespeicherten Routine oder lokale Variable |
3 |
Systemkonstante |
USER() -Rückgabewert |
4 |
Sortierfolgenvorrang einstellbar | Literaler String |
5 |
Ignorierbar |
NULL oder ein Ausdruck, der von
NULL abgeleitet wurde |
Gibt die Sortierung des String-Arguments zurück.
mysql>SELECT COLLATION('abc');
-> 'latin1_swedish_ci' mysql>SELECT COLLATION(_utf8'abc');
-> 'utf8_general_ci'
Gibt die Verbindungskennung (Thread-ID) der Verbindung zurück. Jede Verbindung hat eine Kennung, die in der Gesamtzahl der aktuell verbundenen Clients eindeutig ist.
mysql> SELECT CONNECTION_ID();
-> 23786
Gibt die Kombination aus Benutzer- und Hostnamen für das
MySQL-Konto zurück, das der Server zur Authentifizierung
des aktuellen Clients verwendet hat. Dieses Konto bestimmt
Ihre Zugriffsberechtigungen. Innerhalb einer gespeicherten
Routine, die mit dem Merkmal SQL SECURITY
DEFINER
definiert wurde, gibt
CURRENT_USER()
den Ersteller der Routine
zurück. Der Rückgabewert ist ein String im Zeichensatz
utf8
.
Der Wert von CURRENT_USER()
kann sich vom
Wert von USER()
unterscheiden.
mysql>SELECT USER();
-> 'davida@localhost' mysql>SELECT * FROM mysql.user;
ERROR 1044: Access denied for user ''@'localhost' to database 'mysql' mysql>SELECT CURRENT_USER();
-> '@localhost'
Das Beispiel veranschaulicht, dass, obwohl der Client den
Benutzernamen davida
(gemäß dem Wert
der Funktion USER()
) angegeben hat, der
Server den Client unter Verwendung eines anonymen
Benutzerkontos authentifiziert hat. Dies geht aus dem leeren
Benutzernamensteil des
CURRENT_USER()
-Werts hervor. Eine
mögliche Ursache hierfür besteht darin, dass in den
Grant-Tabellen kein Konto davida
aufgeführt ist.
Gibt den Namen der Standarddatenbank (d. h. der aktuellen
Datenbank) als String im Zeichensatz utf8
zurück. Ist keine Standarddatenbank vorhanden, dann gibt
DATABASE()
NULL
zurück. Innerhalb einer gespeicherten Routine ist die
Standarddatenbank diejenige, mit der die Routine assoziiert
ist. Dies muss nicht unbedingt die gleiche Datenbank sein,
die als Standarddatenbank im aufrufenden Kontext verwendet
wird.
mysql> SELECT DATABASE();
-> 'test'
Ist keine Standarddatenbank vorhanden, dann gibt
DATABASE()
NULL
zurück.
Eine SELECT
-Anweisung kann eine
LIMIT
-Klausel enthalten, die die Anzahl
der Datensätze beschränkt, die der Server an den Client
zurückgibt. In manchen Fällen kann es wünschenswert sein,
zu wissen, wie viele Datensätze die Anweisung ohne
LIMIT
-Klausel zurückgegeben hätte, ohne
dass man die Anweisung hierzu erneut ausführen müsste. Um
diese Anzahl zu ermitteln, fügen Sie die Option
SQL_CALC_FOUND_ROWS
in die
SELECT
-Anweisung ein und rufen danach
FOUND_ROWS()
auf:
mysql>SELECT SQL_CALC_FOUND_ROWS * FROM
->tbl_name
WHERE id > 100 LIMIT 10;
mysql>SELECT FOUND_ROWS();
Die zweite SELECT
-Anweisung gibt eine
Zahl zurück, die angibt, wie viele Datensätze die erste
SELECT
-Anweisung zurückgegeben hätte,
wenn die LIMIT
-Klausel nicht enthalten
gewesen wäre. (Wenn die vorangegangene
SELECT
-Anweisung die Option
SQL_CALC_FOUND_ROWS
nicht enthält, dann
gibt FOUND_ROWS()
mit
LIMIT
unter Umständen ein anderes
Ergebnis als ohne.)
Die mit FOUND_ROWS()
ermittelte Anzahl
der Datensätze ist flüchtig und sollte nicht über die der
SELECT SQL_CALC_FOUND_ROWS
-Anweisung
nachfolgende Anweisung hinaus verfügbar bleiben. Wenn Sie
den Wert später noch einmal benötigen sollten, dann
sollten Sie ihn speichern:
mysql>SELECT SQL_CALC_FOUND_ROWS * FROM ... ;
mysql>SET @rows = FOUND_ROWS();
Wenn Sie SELECT SQL_CALC_FOUND_ROWS
verwenden, muss MySQL berechnen, wie viele Datensätze in
der vollständigen Ergebnismenge enthalten sind. Allerdings
ist dies schneller, als die Abfrage ohne
LIMIT
erneut auszuführen, weil die
Ergebnismenge nicht an den Client gesendet werden muss.
SQL_CALC_FOUND_ROWS
und
FOUND_ROWS()
können in Situationen
nützlich sein, in denen Sie die Anzahl der von einer
Abfrage zurückgegebenen Datensätze beschränken, aber auch
die Anzahl der Datensätze im vollständigen Ergebnis
ermitteln wollen, ohne die Abfrage erneut auszuführen. Ein
Beispiel hierfür wäre ein Webskript, das seitenweise eine
Darstellung mit Links auf Seiten anzeigt, die auf andere
Bereiche eines Suchergebnisses verweisen. Mithilfe von
FOUND_ROWS()
können Sie bestimmen, wie
viele andere Seiten für den Rest des Ergebnisses benötigt
werden.
Die Verwendung von SQL_CALC_FOUND_ROWS
und FOUND_ROWS()
ist bei
UNION
-Anweisungen komplexer als bei
einfachen SELECT
-Anweisungen, weil
LIMIT
an mehreren Stellen in einer
UNION
auftreten kann. Es kann auf
einzelne SELECT
-Anweisungen in der
UNION
oder aber global auf das Ergebnis
der UNION
als Ganzes angewendet werden.
Der Zweck von SQL_CALC_FOUND_ROWS
bei
UNION
besteht in der Rückgabe der Anzahl
von Datensätzen, die ohne globale
LIMIT
-Klausel zurückgegeben worden
wäre. Die Benutzung von
SQL_CALC_FOUND_ROWS
mit
UNION
ist folgenden Bedingungen
unterworfen:
Das Schlüsselwort
SQL_CALC_FOUND_ROWS
muss in der
ersten SELECT
-Anweisung der
UNION
auftreten.
Der Wert von FOUND_ROWS()
ist nur
exakt, wenn UNION ALL
verwendet wird.
Wenn UNION
ohne
ALL
verwendet wird, findet eine
Entfernung von Dubletten statt, weswegen der Wert von
FOUND_ROWS()
nur näherungsweise ist.
Wenn LIMIT
nicht in der
UNION
vorhanden ist, wird
SQL_CALC_FOUND_ROWS
ignoriert und
gibt die Anzahl der Reihen in der Temporärtabelle
zurück, die zur Verarbeitung der
UNION
verwendet wird.
LAST_INSERT_ID()
,
LAST_INSERT_ID(
expr
)
Gibt den ersten automatisch erzeugten
Wert zurück, der für eine
AUTO_INCREMENT
-Spalte durch die
aktuelle INSERT
-
oder UPDATE
-Anweisung eingestellt wurde,
die eine solche Spalte modifiziert hat.
mysql> SELECT LAST_INSERT_ID();
-> 195
Die erzeugte Kennung wird auf dem Server
verbindungsspezifisch gehandhabt: Der
von der Funktion an einen bestimmten Client zurückgegebene
Wert ist der erste AUTO_INCREMENT
-Wert,
der für die zuletzt abgesetzte Anweisung, die eine
AUTO_INCREMENT
-Spalte betraf,
von diesem Client erzeugt wurde. Dieser
Wert darf nicht von anderen Clients bearbeitet werden, auch
wenn diese selbst AUTO_INCREMENT
-Werte
erzeugen. Dieses Verhalten gewährleistet, dass jeder Client
seine eigene Kennung abrufen kann, ohne die Aktivitäten
anderer Clients berücksichtigen oder Sperren setzen bzw.
Transaktionen verwenden zu müssen.
Der Wert von LAST_INSERT_ID()
wird nicht
geändert, wenn Sie die
AUTO_INCREMENT
-Spalte eines Datensatzes
auf einen „nichtmagischen“ Wert (d. h. einen
Wert, der nicht NULL
und nicht
0
ist) setzen.
Wichtig: Wenn Sie mehrere
Datensätze mithilfe einer einzelnen
INSERT
-Anweisung einfügen, gibt
LAST_INSERT_ID()
nur
denjenigen Wert zurück, der für den
ersten eingefügten Datensatz erzeugt
wurde. Grund hierfür ist, dass es möglich sein soll,
dieselbe INSERT
-Anweisung problemlos auf
einem anderen Server zu reproduzieren.
Zum Beispiel:
mysql>USE test;
Database changed mysql>CREATE TABLE t (
->id INT AUTO_INCREMENT NOT NULL PRIMARY KEY,
->name VARCHAR(10) NOT NULL
->);
Query OK, 0 rows affected (0.09 sec) mysql>INSERT INTO t VALUES (NULL, 'Bob');
Query OK, 1 row affected (0.01 sec) mysql>SELECT * FROM t;
+----+------+ | id | name | +----+------+ | 1 | Bob | +----+------+ 1 row in set (0.01 sec) mysql>SELECT LAST_INSERT_ID();
+------------------+ | LAST_INSERT_ID() | +------------------+ | 1 | +------------------+ 1 row in set (0.00 sec) mysql>INSERT INTO t VALUES
->(NULL, 'Mary'), (NULL, 'Jane'), (NULL, 'Lisa');
Query OK, 3 rows affected (0.00 sec) Records: 3 Duplicates: 0 Warnings: 0 mysql> SELECT * FROM t; +----+------+ | id | name | +----+------+ | 1 | Bob | | 2 | Mary | | 3 | Jane | | 4 | Lisa | +----+------+ 4 rows in set (0.01 sec) mysql>SELECT LAST_INSERT_ID();
+------------------+ | LAST_INSERT_ID() | +------------------+ | 2 | +------------------+ 1 row in set (0.00 sec)
Obwohl die zweite INSERT
-Anweisung drei
neue Datensätze in t
eingefügt hat, war
die für den ersten dieser Datensätze erzeugte Kennung
2
, und diesen Wert hat
LAST_INSERT_ID()
auch für die folgende
SELECT
-Anweisung zurückgegeben.
Wenn Sie INSERT IGNORE
verwenden und der
Datensatz ignoriert wird, wird der
AUTO_INCREMENT
-Zähler nicht erhöht, und
LAST_INSERT_ID()
gibt
0
zurück, um anzuzeigen, dass kein
Datensatz eingefügt wurde.
Wenn expr
als Argument für
LAST_INSERT_ID()
angegeben wird, wird der
Wert des Arguments von der Funktion zurückgegeben und als
nächster Wert von LAST_INSERT_ID()
zurückzugebender Wert vermerkt. Dies kann zur Simulierung
von Sequenzen verwendet werden:
Erstellen Sie eine Tabelle zur Aufnahme des Sequenzzählers und initialisieren Sie sie:
mysql>CREATE TABLE sequence (id INT NOT NULL);
mysql>INSERT INTO sequence VALUES (0);
Erstellen Sie mit dieser Tabelle wie folgt Sequenznummern:
mysql>UPDATE sequence SET id=LAST_INSERT_ID(id+1);
mysql>SELECT LAST_INSERT_ID();
Die UPDATE
-Anweisung erhöht den
Sequenzzähler und sorgt dafür, dass der nächste
Aufruf von LAST_INSERT_ID()
den
aktualisierten Wert zurückgibt. Die
SELECT
-Anweisung ruft diesen Wert ab.
Die C-API-Funktion mysql_insert_id()
kann ebenfalls zum Abrufen des Werts verwendet werden.
Siehe auch Abschnitt 24.2.3.36, „mysql_insert_id()
“.
Sie können Sequenzen zwar auch ohne Aufruf von
LAST_INSERT_ID()
erzeugen, aber die
Funktion auf diese Weise zu verwenden hat den Vorteil, dass
der Kennungswert am Server als letzter automatisch erzeugter
Wert vermerkt wird. Dies ist im Multiuser-Betrieb sicher,
weil mehrere Clients die Anweisung UPDATE
absetzen und jeweils einen eigenen Sequenzwert mit der
SELECT
-Anweisung (oder
mysql_insert_id()
) erhalten, ohne andere
Clients, die eigene Sequenzwerte erstellen, zu
beeinträchtigen bzw. von ihnen beeinträchtigt zu werden.
Beachten Sie, dass mysql_insert_id()
erst
nach den INSERT
- und
UPDATE
-Anweisungen aktualisiert wird,
d. h., Sie können die C-API-Funktion nicht zum Abrufen des
Werts von
LAST_INSERT_ID(
verwenden, nachdem andere SQL-Anweisungen wie
expr
)SELECT
oder SET
ausgeführt wurden.
ROW_COUNT()
gibt die Anzahl der von der
vorherigen Anweisung aktualisierten, eingefügten oder
gelöschten Datensätze zurück. Dies entspricht der
Datensatzanzahl, die vom Client mysql
angezeigt wird, und dem Wert der C-API-Funktion
mysql_affected_rows()
.
mysql>INSERT INTO t VALUES(1),(2),(3);
Query OK, 3 rows affected (0.00 sec) Records: 3 Duplicates: 0 Warnings: 0 mysql>SELECT ROW_COUNT();
+-------------+ | ROW_COUNT() | +-------------+ | 3 | +-------------+ 1 row in set (0.00 sec) mysql>DELETE FROM t WHERE i IN(1,2);
Query OK, 2 rows affected (0.00 sec) mysql>SELECT ROW_COUNT();
+-------------+ | ROW_COUNT() | +-------------+ | 2 | +-------------+ 1 row in set (0.00 sec)
Diese Funktion ist synonym zu DATABASE()
.
SESSION_USER()
ist ein Synonym für
USER()
.
SYSTEM_USER()
ist ein Synonym für
USER()
.
Gibt den aktuellen MySQL-Benutzer- und Hostnamen als String
im Zeichensatz utf8
zurück.
mysql> SELECT USER();
-> 'davida@localhost'
Der Wert gibt den Benutzernamen, den Sie beim Herstellen der
Verbindung zum Server eingegeben haben, und den Clienthost
an, über den die Verbindung hergestellt wurde. Der Wert
kann sich von dem von CURRENT_USER()
unterscheiden.
Sie können den Benutzernamensanteil wie folgt extrahieren:
mysql> SELECT SUBSTRING_INDEX(USER(),'@',1);
-> 'davida'
Gibt einen String zurück, der die MySQL Server-Version
angibt. Der String verwendet den Zeichensatz
utf8
.
mysql> SELECT VERSION();
-> '5.1.5-alpha-standard'
Beachten Sie, dass, wenn Ihr Versions-String mit
-log
endet, dies bedeutet, dass das
Loggen aktiviert ist.
Dies ist eine Übersetzung des MySQL-Referenzhandbuchs, das sich auf dev.mysql.com befindet. Das ursprüngliche Referenzhandbuch ist auf Englisch, und diese Übersetzung ist nicht notwendigerweise so aktuell wie die englische Ausgabe. Das vorliegende deutschsprachige Handbuch behandelt MySQL bis zur Version 5.1.