BENCHMARK(count,expr)

La función BENCHMARK() ejecuta la expresión expr repetidamente count veces. Puede usarse para ver lo rápido que MySQL procesa la expresión. El valor resultado siempre es 0. El uso pretendido es desde dentro del cliente mysql, que reporte tiempos de ejecución de consultas:

mysql> SELECT BENCHMARK(1000000,ENCODE('hello','goodbye'));
+----------------------------------------------+
| BENCHMARK(1000000,ENCODE('hello','goodbye')) |
+----------------------------------------------+
|                                            0 |
+----------------------------------------------+
1 row in set (4.74 sec)

El tiempo reportado es el tiempo transcurrido en el cliente final no el tiempo de CPU en el servidor. Se recomienda ejecutar BENCHMARK() varias veces, y interpretar el resultado teniendo en cuenta la carga de la máquina servidor.

CHARSET(str)

Retorna el conjunto de caracteres el argumento cadena.

mysql> SELECT CHARSET('abc');
        -> 'latin1'
mysql> SELECT CHARSET(CONVERT('abc' USING utf8));
        -> 'utf8'
mysql> SELECT CHARSET(USER());
        -> 'utf8'

COERCIBILITY(str)

Retorna la coerzabilidad de la colación del argumento.

mysql> SELECT COERCIBILITY('abc' COLLATE latin1_swedish_ci);
        -> 0
mysql> SELECT COERCIBILITY(USER());
        -> 3
mysql> SELECT COERCIBILITY('abc');
        -> 4

El valor de retorno tiene los siguientes significados:

Antes de MySQL 5.0.3, los valores de retorno se muestran como sigue, y las funciones tales como USER() tienen una coerzabilidad de 2:

Los valores menores tienen precedencia mayor.

COLLATION(str)

Retorna la colación para el conjunto de caracteres de la cadena dada.

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

CONNECTION_ID()

Retorna el ID de la conexión (ID del thread) para la conexión. Cada conexión tiene su propio y único ID.

mysql> SELECT CONNECTION_ID();
        -> 23786

CURRENT_USER()

Retorna la combinación de nombre de usuario y de equipo que tiene la sesión actual. Este valor se corresponde con la cuenta MySQL que determina sus privilegios de aceso. Puede ser distinto al valor de USER().

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'

El ejemplo ilustra que aunque el cliente especica un nombre de usuario de davida (como se indica por el valor de la función USER() ), el servidor autentica al cliente usando una cuenta de usuario anónimo (como se ve por la parte de usuario vacía del valor CURRENT_USER() ). Una forma en que esto puede ocurrir es que no haya cuenta listada en las cuentas de permisos para davida.

En MySQL 5.0, la cadena retornada por CURRENT_USER() usa el conjunto de caracteres utf8 .

DATABASE()

Retorna el nombre de base de datos por defecto (actual). En MySQL 5.0, la cadena tiene el conjunto de caracteres utf8 .

mysql> SELECT DATABASE();
        -> 'test'

No hay base de datos por defecto, DATABASE() retorna NULL.

FOUND_ROWS()

Un comando SELECT puede incluir una cláusula LIMIT para restringir el número de registros que el servidor retorna al cliente. En algunos casos, es deseable saber cuántos registos habría retornado el comando sin LIMIT, pero sin volver a lanzar el comando. Para obtener este conteo de registros, incluya la opción SQL_CALC_FOUND_ROWS en el comando SELECT , luego invoque FOUND_ROWS() :

mysql> SELECT SQL_CALC_FOUND_ROWS * FROM tbl_name
    -> WHERE id > 100 LIMIT 10;
mysql> SELECT FOUND_ROWS();

El segundo SELECT retorna un número indicando cuantos registros habría retornado el primer SELECT sin la cláusula LIMIT . (Si el comando precendente no incluye la opción SQL_CALC_FOUND_ROWS , FOUND_ROWS() puede retornar un resultado distinto cuando se usa LIMIT y cuando no.)

Tenga en cuenta que si usa SELECT SQL_CALC_FOUND_ROWS, MySQL debe calcular cuántos registros hay en el conjunto de resultdos completo. Sin embargo, esto es más rápido que ejecutar la consulta de nuevo sin LIMIT, ya que el conjunto de resultados no necesita ser enviado al cliente.

SQL_CALC_FOUND_ROWS y FOUND_ROWS() pueden ser útiles en situaciones donde puede querer restringir el número de registros que retorna una consulta, pero también determinar el número de registros en el conjunto de resultados entero sin ejecutar la consulta de nuevo. Un ejemplo es el script Web que presenta una salida paginada conteniendo enlaces a las páginas que muestran otras secciones de un resultado de búsqueda. Usando FOUND_ROWS() puede determinar cuántas páginas necesita para el resto de resultados.

El uso deSQL_CALC_FOUND_ROWS y FOUND_ROWS() es más complejo para consultas UNION que para comandos SELECT simples, ya que LIMIT puede ocurrir en varios lugares en una UNION. Puede aplicarse a comandos SELECT individuales en la UNION, o global en el resultado de UNION como conjunto.

La intención de SQL_CALC_FOUND_ROWS para UNION es que debe retornar el número de registros que se retornarían sin un LIMIT globar. Las condiciones para uso de SQL_CALC_FOUND_ROWS con UNION son:

LAST_INSERT_ID(), LAST_INSERT_ID(expr)

Retorna el último valor generado automáticamente que se insertó en una columna AUTO_INCREMENT.

mysql> SELECT LAST_INSERT_ID();
        -> 195

El último ID generado se mantiene en el servidor para cada conexión. Esto significa que el valor de la función retorna a cada cliente el valor AUTO_INCREMENT más reciente generado por ese cliente. Este valor no puede ser afectado por otros clientes, incluso si generan valores AUTO_INCREMENT ellos mismos. Este comportamiento asegura que reciba sus propios IDs sin tener en cuenta la actividad de otros clientes y sin la necesidad de bloqueos o transacciones.

El valor de LAST_INSERT_ID() no cambia si actualiza la columna AUTO_INCREMENT de un registro con un valor no mágico (esto es, un valor que no es NULL ni 0).

Si inserta varios registros a la vez con un comando de inserción LAST_INSERT_ID() retorna el valor del primer registro insertado. La razón para esto es hacer posible reproducir fácilmente el mismo comando INSERT contra otro servidor.

Si usa INSERT IGNORE y el registro se ignora, el contador AUTO_INCREMENT no se incrementa y LAST_INSERT_ID() retorna 0, lo que refleja que no se ha insertado ningún registro. (Antes de MySQL 4.1, AUTO_INCREMENT el contador se incrementa y LAST_INSERT_ID() retorna el nuevo valor.)

Si se da expr como argumento para LAST_INSERT_ID(), el valor del argumento se retorna por la función y se recuerda como el siguiente valor a ser retornado por LAST_INSERT_ID(). Esto puede usarse para simular secuencias:

Puede generar secuencias sin llamar a LAST_INSERT_ID(), pero la utilidad de usar esta función de esta forma es que el valor ID se mantiene en el servidor como el último valor generado automáticamente. Es válido para multi usuarios porque varios clientes pueden realizar el comando UPDATE y obtener su propio valor de secuencia con el comando SELECT (o mysql_insert_id()), sin afectar o ser afectado por otros clientes que generen sus propios valores de secuencia.

Tenga en cuenta que mysql_insert_id() sólo se actualiza tras los comandos INSERT y UPDATE , así que no puede usar la función de la API C para recibir el valor de LAST_INSERT_ID(expr) tras ejecutar otros comandos SQL como SELECT o SET.

ROW_COUNT()

ROW_COUNT() retorna el número de registros actualizados, insertados o borrados por el comando precedente. Esto es lo mismo que el número de registros que muestra el cliente mysql y el valor de la función de la API C 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)

ROW_COUNT() se añadió en MySQL 5.0.1.

SESSION_USER()

SESSION_USER() es sinónimo de USER().

SYSTEM_USER()

SYSTEM_USER() es sinónimo de USER().

USER()

Retorna el nombre de usuario y de equipo de MySQL actual.

mysql> SELECT USER();
        -> 'davida@localhost'

El valor indica el nombre de usuario especificado al conectar con el servidor, y el equipo cliente desde el que se está conectando. El valor puede ser distinto del de CURRENT_USER().

Puede extraer la parte de nombre de usuario así:

mysql> SELECT SUBSTRING_INDEX(USER(),'@',1);
        -> 'davida'

En MySQL 5.0, USER() retorna un valor en el conjunto de caracteres utf8, así que debe asegurarse que la literal '@' se interpreta en el conjunto de caracteres:

mysql> SELECT SUBSTRING_INDEX(USER(),_utf8'@',1);
        -> 'davida'

VERSION()

Retorna una cadena que indica la versión del servidor MySQL. La cadena usa el conjunto de caracteres utf8 .

mysql> SELECT VERSION();
        -> '5.0.9-standard'

Tenga en cuenta que si su cadena de versión acaba con -log significa que el logueo está activado.