BENCHMARK(count,expr)

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.

CHARSET(str)

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'

COERCIBILITY(str)

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.

COLLATION(str)

Gibt die Sortierung des String-Arguments zurück.

mysql> SELECT COLLATION('abc');
        -> 'latin1_swedish_ci'
mysql> SELECT COLLATION(_utf8'abc');
        -> 'utf8_general_ci'

CONNECTION_ID()

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

CURRENT_USER, CURRENT_USER()

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.

DATABASE()

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.

FOUND_ROWS()

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:

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:

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(expr) verwenden, nachdem andere SQL-Anweisungen wie SELECT oder SET ausgeführt wurden.

ROW_COUNT()

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)

SCHEMA()

Diese Funktion ist synonym zu DATABASE().

SESSION_USER()

SESSION_USER() ist ein Synonym für USER().

SYSTEM_USER()

SYSTEM_USER() ist ein Synonym für USER().

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'

VERSION()

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.