SHOW TABLES

SHOW [FULL|OPEN] TABLES [FROM nombre_db] [LIKE 'patrón']

SHOW TABLES lista las tablas no temporales en una base de datos dada. También se puede obtener esta lista usando el comando mysqlshow db_name.

Antes de MySQL 5.0.1, la salida de SHOW TABLES contiene una única columna con los nombres de las tablas. A partir de MySQL 5.0.1, también se listan las vistas de la base de datos. A partir de MySQL 5.0.2, se soporta el modificador FULL de modo que SHOW FULL TABLES muestra una segunda columna. Los valores de esta segunda columna son BASE TABLE para una tabla y VIEW para una vista.

Nota: si no se dispone de privilegios para una tabla, la tabla no será mostrada en la salida de SHOW TABLES o mysqlshow db_name.

SHOW OPEN TABLES lista las tablas que estén actualmente abiertas en la caché de tablas. El campo de comentario en la salida indica las veces que la tabla está en el caché y en uso. OPEN puede usarse a partir de MySQL 3.23.33.

UPDATE

UPDATE [LOW_PRIORITY] [IGNORE] tbl_name
   SET col_name1=expr1 [, col_name2=expr2 ...]
   [WHERE where_definition]
   [ORDER BY ...]
   [LIMIT row_count]

O:

UPDATE [LOW_PRIORITY] [IGNORE] tbl_name [, tbl_name ...]
   SET col_name1=expr1 [, col_name2=expr2 ...]
   [WHERE where_definition]

UPDATE actualiza columnas de filas existentes de una tabla con nuevos valores. La cláusula SET indica las columnas a modificar y los valores que deben tomar. La cláusula WHERE, si se da, especifica qué filas deben ser actualizadas. Si no se especifica, serán actualizadas todas ellas. Si se especifica la cláusula ORDER BY, las filas se modificarán en el orden especificado. La cláusula LIMIT establece un límite al número de filas que se pueden actualizar.

La sentencia UPDATE soporta los modificadores siguientes:

• Si se usa la palabra LOW_PRIORITY, la ejecución de UPDATE se retrasará hasta que no haya otros clientes haciendo lecturas de la tabla.
• Si se especifica IGNORE, la sentencia UPDATE no se abortará si se producen errores durante la actualización. Las filas con conflictos de claves duplicadas no se actualizarán. Las filas para las que la actualización de columnas se puedan producir errores de conversión se actualizarán con los valores válidos más próximos.

Si se accede a una columna de "tbl_name" en una expresión, UPDATE usa el valor actual de la columna. Por ejemplo, la siguiente sentencia asigna a la columna "edad" su valor actual más uno:

mysql> UPDATE persondata SET edad=edad+1;

Las asignaciones UPDATE se evalúan de izquierda a derecha. Por ejemplo, las siguientes sentencias doblan el valor de la columna "edad", y después la incrementan:

mysql> UPDATE persondata SET edad=edad*2, edad=edad+1;

Si se asigna a una columna el valor que tiene actualmente, MySQL lo notifica y no la actualiza.

Si se actualiza una columna que ha sido declarada como NOT NULL con el valor NULL, se asigna el valor por defecto apropiado para el tipo de la columna y se incrementa en contador de avisos. El valor por defecto es 0 para tipos numéricoss, la cadena vacía ('') para tipos de cadena, y el valor "cero" para tipos de fecha y tiempo.

UPDATE devuelve el número de filas que se han modificado. A partir de la versión 3.22 de MySQL, la función de API C mysql_info devuelve el número de filas que han coincidido y actualizado, y el número de avisos que se han obtenido durante la actualización.

Desde la versión 3.23 de MySQL, se puede usar LIMIT row_count para restringir el rango de actualización. La cláusula LIMIT trabaja del modo siguiente:

• Antes de MySQL 4.0.13, LIMIT restringía el número de filas afectadas. La sentencia se detiene tan pronto como de modifican "row_count" filas que satisfagan la cláusula WHERE.
• Desde 4.0.13, LIMIT se restringe al número de filas coincidentes. La sentencia se detiene tan pronto como se encuentran "row_count" filas que satisfagan la cláusula WHERE, tanto si se han modificado como si no.

Si se usa una cláusula ORDER BY, las filas serán actualizadas en el orden especificado. ORDER BY está disponible desde MySQL 4.0.0.

Desde la versión 4.0.4 de MySQL, también es posible realizar operaciones UPDATE que cubran múltiples tablas:

UPDATE items,month SET items.price=month.price
     WHERE items.id=month.id;

El ejemplo muestra una fusión interna usando el operador coma, pero un UPDATE multitabla puede usar cualquier tipo de fusión (join) permitido en sentencias SELECT, como un LEFT JOIN.

Nota: no es posible usar ORDER BY o LIMIT con UPDATE multitabla.

Si se usa una sentencia UPDATE multitabla que afecte a tablas InnoDB para las que haya definiciones de claves foráneas, el optimizador MySQL procesará las tablas en un orden diferente del de la relación padre/hijo. En ese caso, la sentencia puede fallar y deshará los cambios (roll back). En su lugar, se debe actualizar una tabla y confiar el las capacidades de ON UPDATE que proporciona InnoDB que harán que las otras tablas se modifiquen del modo adecuado.

Actualmente, no se puede actualizar una tabla y seleccionar desde la misma en una subconsulta.

SHOW DATABASES

SHOW {DATABASES | SCHEMAS} [LIKE 'patrón']

SHOW DATABASES lista las bases de datos en el ordenador del servidor MySQL. También se puede obtener esa lista usando el comando mysqlshow. Desde MySQL 4.0.2, sólo es posible ver aquellas bases de datos para las cuales se dispone algún tipo de privilegio, si no se posee el privilegio global SHOW DATABASES.

Si el servidor fue arrancado con la opción --skip-show-database, no se podrá usar esta sentencia de ninguna manera, salvo que se disponga del privilegio SHOW DATABASES.

SHOW SCHEMAS se puede usar desde MySQL 5.0.2.

SHOW CREATE VIEW

SHOW CREATE VIEW view_name

Esta sentencia muestra una sentencia CREATE VIEW que creará la vista dada.

mysql> SHOW CREATE VIEW v;
+-------+----------------------------------------------------+
| Table | Create Table                                       |
+-------+----------------------------------------------------+
| v     | CREATE VIEW `test`.`v` AS select 1 AS `a`,2 AS `b` |
+-------+----------------------------------------------------+

Esta sentencia se añadió en MySQL 5.0.1.

SHOW CREATE DATABASE

SHOW CREATE {DATABASE | SCHEMA} db_name

Muestra una sentencia CREATE DATABASE que creará la base de datos dada. Fue añadida en MySQL 4.1. SHOW CREATE SCHEMA puede ser usada a partir de MySQL 5.0.2.

mysql> SHOW CREATE DATABASE test\G
*************************** 1. row ***************************
      Database: test
Create Database: CREATE DATABASE `test`
                /*!40100 DEFAULT CHARACTER SET latin1 */

SHOW COLUMNS SHOW FIELDS

SHOW [FULL] COLUMNS FROM tbl_name [FROM db_name] [LIKE 'patrón']

SHOW COLUMNS lista las columnas de una tabla dada. Si los tipos de columna difieren de los que se esperaba a partir de la sentencia CREATE TABLE usada, hay que tener en cuenta que a veces MySQL cambia tipos de columnas cuando se crea o altera una tabla. Las condiciones para que esto ocurra se describen al final de CREATE TABLE.

La palabra clave FULL se puede usar a partir de MySQL 3.23.32. Hace que la salida incluya los privilegios que se poseen para cada columna. A partir de MySQL 4.1, FULL también hace que se muestre cualquier comentario por columna que exista.

Se puede usar db_name.tbl_name como una alternativa a la sintaxis tbl_name FROM db_name syntax. Estas dos sentencias son equivalentes:

mysql> SHOW COLUMNS FROM mytable FROM mydb;
mysql> SHOW COLUMNS FROM mydb.mytable;

SHOW FIELDS es un sinónimo de SHOW COLUMNS. También se pueden listar las columnas de una tabla con el comando mysqlshow db_name tbl_name.

La sentencia DESCRIBE proporciona información similar a SHOW COLUMNS.

SHOW COLLATION

SHOW COLLATION [LIKE 'pattern']

La salida de SHOW COLLATION incluye todos los conjuntos de caracteres disponibles. La cláusula opcional LIKE indica qué nombres de conjuntos de reglas buscar. Por ejemplo:

mysql> SHOW COLLATION LIKE 'latin1%';
+-------------------+---------+----+---------+----------+---------+
| Collation         | Charset | Id | Default | Compiled | Sortlen |
+-------------------+---------+----+---------+----------+---------+
| latin1_german1_ci | latin1  |  5 |         |          |       0 |
| latin1_swedish_ci | latin1  |  8 | Yes     | Yes      |       0 |
| latin1_danish_ci  | latin1  | 15 |         |          |       0 |
| latin1_german2_ci | latin1  | 31 |         | Yes      |       2 |
| latin1_bin        | latin1  | 47 |         | Yes      |       0 |
| latin1_general_ci | latin1  | 48 |         |          |       0 |
| latin1_general_cs | latin1  | 49 |         |          |       0 |
| latin1_spanish_ci | latin1  | 94 |         |          |       0 |
+-------------------+---------+----+---------+----------+---------+

La columna Default indica si un conjunto de reglas (collation) es el usado por defecto para un conjunto de caracteres. Compiled indica si el conjunto de caracteres está compilado en el servidor. Sortlen está relacionado con la cantidad de memoria requerida para ordenar cadenas expresadas en el conjunto de caracteres.

SHOW COLLATION está disponible a partir de MySQL 4.1.0.

SHOW CHARACTER SET

SHOW CHARACTER SET [LIKE 'pattern']

La sentencia SHOW CHARACTER SET muestra los conjuntos de caracteres disponibles. Puede tener una cláusula opcional LIKE que indique qué nombres de conjuntos de caracteras buscar. Por ejemplo:

mysql> SHOW CHARACTER SET LIKE 'latin%';
+---------+-----------------------------+-------------------+--------+
| Charset | Description                 | Default collation | Maxlen |
+---------+-----------------------------+-------------------+--------+
| latin1  | ISO 8859-1 West European    | latin1_swedish_ci |      1 |
| latin2  | ISO 8859-2 Central European | latin2_general_ci |      1 |
| latin5  | ISO 8859-9 Turkish          | latin5_turkish_ci |      1 |
| latin7  | ISO 8859-13 Baltic          | latin7_general_ci |      1 |
+---------+-----------------------------+-------------------+--------+

La columna Maxlen muestra el número máximo de bytes usados para almacenar un carácter.

SHOW CHARACTER SET está disponible a partir de MySQL 4.1.0.

SHOW

SHOW [FULL] COLUMNS FROM tbl_name [FROM db_name] [LIKE 'patrón']
SHOW CREATE DATABASE db_name
SHOW CREATE TABLE tbl_name
SHOW DATABASES [LIKE 'pattern']
SHOW [STORAGE] ENGINES
SHOW ERRORS [LIMIT [offset,] row_count]
SHOW GRANTS FOR user
SHOW INDEX FROM tbl_name [FROM db_name]
SHOW INNODB STATUS
SHOW [BDB] LOGS
SHOW PRIVILEGES
SHOW [FULL] PROCESSLIST
SHOW STATUS [LIKE 'pattern']
SHOW TABLE STATUS [FROM db_name] [LIKE 'pattern']
SHOW [OPEN] TABLES [FROM db_name] [LIKE 'pattern']
SHOW [GLOBAL | SESSION] VARIABLES [LIKE 'pattern']
SHOW WARNINGS [LIMIT [offset,] row_count]

SHOW proporciona información sobre bases de datos, tablas, columnas o información de estado sobre el servidor. Si se usa la parte LIKE, la cadena de patrón puede usar los caracteres '%' y '_' como comodines. El patrón es útil para restringir la salida de la sentencia a los valores que coincidan con él.

Existen otros formatos de estas sentencias:

La sentencia SHOW tiene formatos que proporcionan información sobre replicado de servidores maestros y esclavos:

SHOW BINLOG EVENTS
SHOW MASTER LOGS
SHOW MASTER STATUS
SHOW SLAVE HOSTS
SHOW SLAVE STATUS

SET TRANSACTION

SET [GLOBAL | SESSION] TRANSACTION ISOLATION LEVEL
 { READ UNCOMMITTED | READ COMMITTED | REPEATABLE READ | SERIALIZABLE }

Asigna el nivel de aislamiento de transacción para transacciones globales, la sesión completa o para la siguiente transacción.

El comportamiento por defecto es asignar el nivel de aislamiento para la siguiente transacción (no comenzada). Si se usa GLOBAL, la sentencia asigna el nivel de transacción global por defecto para todas las nuevas conexiones creadas desde ese punto (pero no para las conexiones existentes). Se necesita el privilegio SUPER para hacer esto. Usando la opción SESSION se asigna el nivel de transacción por defecto para todas las futuras transacciones realizadas en la conexión actual.

InnoDB soporta cada uno de estos niveles desde MySQL 4.0.5. El nivel por defecto es REPEATABLE READ.

Se puede asignar el nivel de aislamiento global por defecto para mysqld con --transaction-isolation=....

SET

SET [GLOBAL | SESSION] sql_variable=expression,
   [[GLOBAL | SESSION] sql_variable=expression] ...

SET activa varias opciones que afectan al funcionamiento del servidor y el cliente.

Los siguientes ejemplos muestran las diferentes sintaxis que se pueden usar para modificar variables:

En versiones antiguas de MySQL está permitido usar la sintaxis SET OPTION, pero esto está desaconsejado ahora.

En MySQL 4.0.3 se han añadido las opciones GLOBAL y SESSION y acceso a las variables de arranque más importantes.

LOCAL se puede usar como sinónimo de SESSION.

Si se modifican varias variables en la misma línea de comando, se usa el último modo GLOBAL | SESSION.

SET sort_buffer_size=10000;
SET @@local.sort_buffer_size=10000;
SET GLOBAL sort_buffer_size=1000000, SESSION sort_buffer_size=1000000;
SET @@sort_buffer_size=1000000;
SET @@global.sort_buffer_size=1000000, @@local.sort_buffer_size=1000000;

La sintaxis @@variable_name se soporta para hacer la sintaxis de MySQL compatible con otras bases de datos.

Las variables de sistema que se pueden modificar se describen en la sección de variables de sistam de este manual.

Si se está usando SESSION (por defecto), la opción modificada permanece en efecto hasta que la sesión actual termine, o hasta que se cambie la opción a un valor diferente. Si se usa GLOBAL, que requiere el privilegio SUPER, la opción se recuerda y se usa para nuevas conexiones hasta que el servidor se reinicie. Si se quiere que una opción se modifique permanentemente, se debe activar en un fichero de opciones.

Para impedir el uso incorrecto, MySQL producirá un error si se usa SET GLOBAL con una variable que sólo se puede usar con SET SESSION o si no se usa SET GLOBAL con una variable global.

Si se quiere cambiar una variable de SESSION a un valor GLOBAL o un valor GLOBAL a su valor por defecto de MySQL, se puede asignar DEFAULT.

SET max_join_size=DEFAULT;

Esto es idéntico a:

SET @@session.max_join_size=@@global.max_join_size;

Si se quiere restringir el valor máximo al que una variable del servidor puede ser asignada, se puede especificar ese máximo usando la opción de línea de comando --maximum-variable-name.

Se puede obtener una lista de la mayoría de las variables con SHOW VARIABLES. Se puede obtener el valor de una variable específica con la sintaxis @@[global.|local.]variable_name:

SHOW VARIABLES like "max_join_size";
SHOW GLOBAL VARIABLES like "max_join_size";
SELECT @@max_join_size, @@global.max_join_size;

A continuación se expone una descripción de las variables que usan una sintaxis no estándar de SET y algunas de las otras variables. El resto de las definiciones de variables pueden encontrarse en la sección de variables del sistema, entre las opciones de arranque o en la descripción de SHOW VARIABLES.

AUTOCOMMIT= 0 | 1

Si se asigna 1, todos los cambios de una tabla se hacen inmediatamente. Para comenzar una transacción multicomando, se debe usar la sentencia BEGIN. Ver también las sintaxis de START TRANSACTION, COMMIT y ROLLBACK. Si se asigna 0 se debe usar COMMIT para aceptar la transacción o ROLLBACK para cancelarla. Cuando se cambia el modo AUTOCOMMIT de 0 a 1, MySQL realiza un COMMIT automático de cualquier transacción abierta.

BIG_TABLES = 0 | 1

Se se asigna 1, todas las tablas temporales se almacenan en disco en lugar de en memoria. Esto puede ser un poco más lento, pero no se obtendrá el error "The table tbl_name is full" para operaciones SELECT grandes que requieren una tabla temporal grande. El valor por defecto para nuevas conexiones es 0 (es decir, usar tablas temporales en memoria). Esta variable fue llamada previamente SQL_BIG_TABLES. En MySQL 4.0, normalmente no será necesario modificar esta variable, ya que MySQL convierte tablas en memoria a tablas en disco de forma automática, cuando es necesario.

CHARACTER SET character_set_name | DEFAULT

Esto mapea todas las cadenas desde y hacia el cliente con el mapeado dado. Actualmente la única opción para character_set_name es "cp1251_koi8", pero se puden añadir fácilmente nuevos mapeados mediante la edición del fichero 'sql/convert.cc' en la distribución fuente de MySQL. El mapeado por defecto puede ser restaurado usando el valor DEFAULT para character_set_name. Puede verse que la sintaxis para cambiar la opción CHARACTER SET difiere de la sintaxis para modificar otras opciones.

INSERT_ID = #

Cambia el valor a uar en el siguiente comando INSERT o ALTER TABLE cuando se inserte un valor AUTO_INCREMENT. Esto se usa principalmente con el diario binario.

LAST_INSERT_ID = #

Cambia el valor que retornará desde LAST_INSERT_ID(). Este se almacena en el diario binario cuando se usa LAST_INSERT_ID() en un comando que actualice una tabla.

LOW_PRIORITY_UPDATES = 0 | 1

Si se asigna 1, todas las sentencias INSERT, UPDATE, DELETE y LOCK TABLE WRITE esperan hasta que no haya sentencias SELECT o LOCK TABLE READ pendientes en al tabla afectada. Esta variable previamente se llamaba SQL_LOW_PRIORITY_UPDATES.

MAX_JOIN_SIZE = value | DEFAULT

No admite sentencias SELECT que probablemente necesiten examinar más más de 'value' combinaciones de valor de fila o es probable que haga más 'value' accesos a disco. Mediante este valor se pueden detener sentencias SELECT donde las claves no se han usado apropiadamente y que es probable que requieran mucho tiempo. Asignando un valor diferente de DEFAULT asigna 0 a SQL_BIG_SELECTS. Si se activa el valor de SQL_BIG_SELECTS otra vez, la variable SQL_MAX_JOIN_SIZE será ignorada. Se puede asignar un valor por defecto para esta variable arrancando mysqld con la opción --max_join_size=value. Esta variable se llamó previamente SQL_MAX_JOIN_SIZE. Si un resultado de una consulta ya está en el caché de consultas, no se realiza ninguna comprobación de tamaño, porque el resultado ya ha sido calculado y y no se cargará al servidor para enviarlo al cliente.

PASSWORD = PASSWORD('some password')

Asigna la contraseña para el usuario actual. Caulquier usuario no anónimo puede modificar su propia contraseña.

PASSWORD FOR user = PASSWORD('some password')

Asigna la constraseña para un usuario específico en el ordenador servidor actual. Sólo un usuario con acceso a la base de datos mysql puede hace esto. El usuario puede darse en el formato user@hostname, donde el 'user' y el 'hostname' son exactamente como aparecen listados en las columnas 'User' y 'Host' de la tabla 'mysql.user'. Por ejemplo, si se tiene una entrada con valores para los campos 'User' y 'Host' de 'bob' and '%.loc.gov', se debe escribir:

mysql> SET PASSWORD FOR 'bob'@'%.loc.gov' = PASSWORD('newpass');

Que es equivalente a:

mysql> UPDATE mysql.user SET Password=PASSWORD('newpass')
   ->                   WHERE User='bob' AND Host='%.loc.gov';
mysql> FLUSH PRIVILEGES;

QUERY_CACHE_TYPE = OFF | ON | DEMAND
QUERY_CACHE_TYPE = 0 | 1 | 2

Modifica la configuración del caché de consultas para este hilo.

Opción	Descripción
0 o OFF	No hay caché para los resultados recuperados.
1 o ON	Se almacenan todos los resultados excepto consultas SELECT SQL_NO_CACHE ....
2 o DEMAND	Se almacenan sólo consultas SELECT SQL_CACHE ....

SQL_AUTO_IS_NULL = 0 | 1

Si se asigna 1 (por defecto), se puede encontrar la última fila insertada en una tabla que contenga una columna AUTO_INCREMENT usando la siguiente construcción: WHERE auto_increment_column IS NULL. Esto se usa por algunos programas ODBC como Access.

SQL_BIG_SELECTS = 0 | 1

Si se asigna 0, MySQL aborta las sentencias SELECT que probablemente requieran mucho tiempo (es decir, sentencias para las que el optimizador estima que el número de filas a examinar excederá el valor de MAX_JOIN_SIZE). Esto es frecuente cuando se usa una sentencia WHERE poco aconsejable. El valor por defecto para una conexión nueva es 1, esto permite todas las sentencias SELECT. Si se asigna a MAX_JOIN_SIZE un valor que no sea DEFAULT, SQL_BIG_SELECTS tomará el valor 0.

SQL_BUFFER_RESULT = 0 | 1

SQL_BUFFER_RESULT fuerza que los resultados de las sentencias SELECT se almacenen en tablas temporales. Esto ayuda a MySQL a liberar bloqueos de tablas más pronto y ayuda en casos donde toma mucho tiempo enviar el conjunto de resultados al cliente.

SQL_LOG_BIN = 0 | 1

Si se asigna 0, no se realiza diario para el cliente en el diario binario, si el cliente tiene el privilegio SUPER.

SQL_LOG_OFF = 0 | 1

Si se asigna 1, no se actualiza el diario estándar para este cliente, si el cliente tiene el privilegio SUPER.

SQL_LOG_UPDATE = 0 | 1

Si se asigna 0, no se actualiza el diario de actualización para el cliente, si el cliente tiene el privilegio SUPER. Esta variable está desaconsejada desde la versión 5.0.

SQL_QUOTE_SHOW_CREATE = 0 | 1

Si se aigna 1, SHOW CREATE TABLE entrecomilla los nombre de la tabla y de las columnas. Por defecto vale 1, de modo que el replicado de tablas funciona con cualquier nombre de campo.

SQL_SAFE_UPDATES = 0 | 1

Si se asigna 1, MySQL aborta sentencias UPDATE o DELETE que no usen una clave o LIMIT en la cláusula WHERE. Esto hace posible detener actualizaciones equivocadas cuando se crean sentencias SQL manualmente.

SQL_SELECT_LIMIT = value | DEFAULT

El máximo número de registros retornados por sentencias SELECT. Si un SELECT tiene una cláusula LIMIT, este valor tiene preferencia sobre el valor de SQL_SELECT_LIMIT. El valor por defecto para una nueva conexión es "unlimited". Si se ha modificado el límite, es posible restaurar el valor por defecto especificando el valor DEFAULT en SQL_SELECT_LIMIT.

TIMESTAMP = timestamp_value | DEFAULT

Cambia la hora para este cliente. Esto se usa para recuperar la hora original si se usar el diario binario para restaurar filas. timestamp_value debe tener el formato Unix 'epoch timestamp', no el de MySQL.

SELECT

SELECT
     [ALL | DISTINCT | DISTINCTROW]
     [HIGH_PRIORITY]
     [STRAIGHT_JOIN]
     [SQL_SMALL_RESULT] [SQL_BIG_RESULT] [SQL_BUFFER_RESULT]
     [SQL_CACHE | SQL_NO_CACHE] [SQL_CALC_FOUND_ROWS]
  select_expr,...
  [INTO OUTFILE 'file_name' export_options]
   | INTO DUMPFILE 'file_name']
  [FROM table_references
     [WHERE where_definition]
     [GROUP BY {col_name | expr | position}
       [ASC | DESC], ... [WITH ROLLUP]]
     [HAVING where_definition]
     [ORDER BY {col_name | expr | position}
       [ASC | DESC] ,...]
     [LIMIT {[offset,] row_count | row_count OFFSET offset}]
     [PROCEDURE procedure_name(argument_list)]
     [FOR UPDATE | LOCK IN SHARE MODE]]

SELECT se usa para recuperar filas selecionadas de una o más tablas. El soporte para sentencias UNION y subconsultas está disponible a partir de MySQL 4.0 y 4.1, respectivamente.

• Cada select_expr indica una columna que se quiere recuperar.
• table_references indica la tabla o tablas de las que se recuperan filas. Su sintaxis se describe en JOIN.
• where_definition consiste de la palabra clave WHERE seguida por una expresión que indica la condición o condiciones que las filas deben satisfacer para ser seleccionadas.

SELECT puede usarse también para recuperar filas calculadas sin referencia a ninguna tabla. Por ejemplo:

mysql> SELECT 1 + 1;
        -> 2

Todas las claúsulas usadas deben darse en el mismo orden exacto que se muestra en la descripción de la sintaxis. Por ejemplo, la cláusula HAVING debe estar después de cualquier cláusula GROUP BY y antes de cualquier cláusula ORDER BY.

• Una select_expr puede usar alias mediante AS nombre_alias. El alias se usa como un nombre de columna en expresiones y puede usarse por las claúsulas ORDER BY o HAVING. Por ejemplo:

mysql> SELECT CONCAT(apellido,', ',nombre) AS nombre_completo
   FROM mitabla ORDER BY nombre_completo;

• La palabra clave AS es opcional cuando se define un alias en una select_expr. El ejemplo anterior se puede escribir como:

mysql>  SELECT CONCAT(apellido,', ',nombre) nombre_completo
   FROM mitabla ORDER BY nombre_completo;

• Debido a que AS es opcional, puede ocurrir un problema si se olvida la coma entre dos select_expr: MySQL interpreta el segundo como un alias. Por ejemplo, en la sentencia siguiente, columnab se trata como un alias:

mysql> SELECT columna columnab FROM mitabla;

• No está permitido usar un alias en una cláusula WHERE, porque el valor de la columna puede que no esté determinado todavía cuando la cláusula WHERE es ejecutada.
• La cláusula FROM table_references indica las tablas desde las que se recuperarán filas. Si se nombra más de una tabla, se realiza una unión (JOIN). Para cada tabla especificada, opcionalmente se puede especificar un alias.
  

  table_name [[AS] alias]
     [[USE INDEX (key_list)]
       | [IGNORE INDEX (key_list)]
       | FORCE INDEX (key_list)]]

  El uso de USE INDEX, IGNORE INDEX, FORCE INDEX para proporcionar al optimizador pistas sobre cómo elegir índices se describe en la sintaxis de JOIN. En MySQL 4.0.14, se puede usar SET max_seeks_for_key=value como una alternativa para forzar a MySQL a elegir un recorrido secuencial por clave en lugar de un recorrido secuencial de la tabla.
Desde la versión 3.23.12 de MySQL, se pueden obtener pistas sobre qué índice debe usar
• Se puede hacer referencia a una tabla con el nombre de la tabla "tbl_name" (dentro de la base de datos actual), o con la especificación completa incluyendo la base de datos "dbname.tbl_name". También se puede hacer referencia a una columna como "col_name", "tbl_name.col_name", o "db_name.tbl_name.col_name". No es necesario especificar un prefijo "tbl_name" o "db_name.tbl_name" para referenciar una columna en una sentencia SELECT a no ser que la referencia pueda resultar ambigua.
• Desde la versión 4.1.0, se puede especificar DUAL como nombre de una tabla vacía, en situaciones en las que no haya tablas definidas.
  

  mysql> SELECT 1 + 1 FROM DUAL;
          -> 2

  Esta es una característica añadida sólo por compatibilidad. Ciertos servidores requieren esa sintaxis.
• Se puede definir un alias a una referencia de tabla mediante tbl_name [AS] alias_name:

mysql> SELECT t1.name, t2.salary FROM employee AS t1, info AS t2
   ->        WHERE t1.name = t2.name;
mysql> SELECT t1.name, t2.salary FROM employee t1, info t2
   ->        WHERE t1.name = t2.name;

• En la cláusula WHERE, se puede usar cualquiera de las funciones soportadas por MySQL, excepto funciones las de reunión (resumen).
• Las columnas seleccionadas pueden ser referenciadas a claúsulas ORDER BY y GROUP BY usando nombres de columna, alias de columna o posiciones de columna. Las posiciones de columna son enteros que empiezan en 1:
  

  mysql> SELECT college, region, seed FROM tournament
     ->        ORDER BY region, seed;
  mysql> SELECT college, region AS r, seed AS s FROM tournament
     ->        ORDER BY r, s;
  mysql> SELECT college, region, seed FROM tournament
     ->        ORDER BY 2, 3;

  Para ordenar en orden inverso se añade la palabra clave DESC (descendente) al nombre de la columna en la cláusula ORDER BY en la que se está ordenando. Por defecto el orden es ascendente, pero puede ser especificado explícitamente por la palabra clave ASC. El uso de posiciones de columna está desaconsejado ya que esa sintaxis ha sido eliminada de SQL estándar.
• Si se usa GROUP BY, la filas de salida serán ordenadas de acuerdo con el GROUP BY como si se hubiese usado ORDER BY sobre los campos del GROUP BY. MySQL ha extendido la cláusula GROUP BY a partir de la versión 3.23.34 de modo que se puede especificar también ASC y DESC después de los nombres de columna en la cláusula:

SELECT a,COUNT(b) FROM test_table GROUP BY a DESC

• MySQL ha extendido el uso de GROUP BY para permitir seleccionar campos que no se han mencionado en la cláusula GROUP BY. Si no se obtiene el resultado esperado de la consulta, leer la descripción de GROUP BY.
• A partir de MySQL 4.1.1, GROUP BY permite el modificador WITH ROLLUP.
• La cláusula HAVING se aplica cerca del final, justo antes de que los resultados se envíen al cliente, sin optimizaciones. (LIMIT se aplica después de HAVING). Antes de MySQL 5.0.2, una cláusula HAVING se puede referir a cualquier columna o alias en la select_expr de lista SELECT o en las subconsultas exteriores, y a las funciones agregadas. SQL estándar requiere que HAVING debe hacer deferencia sólo a columnas en la cláusula GROUP BY o columnas usadas en funciones agregadas. Para permitir ambos comportamientos, el de SQL estándar y el específico de MySQL, que permite referirse a columnas en la lista SELECT, a partir de MySQL 5.0.2 se permite que HAVING se refiera a columnas en la lista SELECT, columnas en la cláusula GROUP BY, columnas en subconsultas exteriores, y a funciones agregadas. Por ejemplo, la siguiente sentencia funciona en MySQL 5.0.2, pero produce un error en versiones anteriores:
  

  mysql> SELECT COUNT(*) FROM t GROUP BY col1 HAVING col1 = 2;

  Si la cláusula HAVING se refiere a una columna que es ambigua, se produce un aviso. En la sentencia siguiente, col2 es ambiguo porque se usa tanto como un alias y como un nombre de columna:
  

  mysql> SELECT COUNT(col1) AS col2 FROM t GROUP BY col2 HAVING col2 = 2;

  Se da preferencia al comportamiento de SQL estándar, así que si un nombre de columna en un HAVING se usa en un GROUP BY y como un alias de columna en la lista de columnas de salida, se toma preferentemente la columna en GROUP BY.
• No se debe usar HAVING para items para los que se pueda usar una cláusula WHERE. Por ejemplo, no escribir esto:
  

  mysql> SELECT col_name FROM tbl_name HAVING col_name > 0;

  Sino esto:

mysql> SELECT col_name FROM tbl_name WHERE col_name > 0;

• La cláusula HAVING se puede referir a funciones agregadas, a las que una cláusula WHERE no puede:
  

  mysql> SELECT user, MAX(salary) FROM users
     ->     GROUP BY user HAVING MAX(salary)>10;

  Sin embargo, esto no funciona en servidores antiguos de MySQL (anteriores a la versión 3.22.5). En su lugar, se puede usar un alias de columna en la lista SELECT y referirse al alias en la cláusula HAVING:

mysql> SELECT user, MAX(salary) AS max_salary FROM users
   ->     GROUP BY user HAVING max_salary>10;

• La cláusula LIMIT puede ser usada para limitar a que el número de filas devuelto por la sentencia SELECT. LIMIT toma uno o dos argumentos numéricos, que deben ser constantes enteras. Con dos argumentos, el primero especifica el desplazamiento de la primera fila a devolver, el segundo especifica el máximo número de filas a devolver. El desplazamiento de la fila inicial es 0 (no 1):
  

  mysql> SELECT * FROM table LIMIT 5,10;  # Recupera filas 6-15

  Por compatibilidad con PostgreSQL, MySQL también soporta la sintaxis: LIMIT row_count OFFSET offset. Para recuperar todas las filas a partir de un desplazamiento concreto hasta el final del conjunto de resultados, se puede usar un número muy grande como segundo parámetro. Esta sentencia recupera todas las filas a partir de la 96 hasta el final:
  

  mysql> SELECT * FROM table LIMIT 95,18446744073709551615;

  Con un argumento, el valor especifica el número de filas a devolver desde el principio del conjunto de resultados.
  

  mysql> SELECT * FROM table LIMIT 5;     # Retrieve first 5 rows

  En otras palabras, LIMIT n equivale a LIMIT 0,n.
• El formato SELECT ... INTO OUTFILE 'file_name' de SELECT escribe las filas seleccionadas en un fichero. El fichero se crea en el host del servidor, de modo que se debe poseer el privilegio FILE para usar esta sintaxis.El fichero no debe existir previamente, entre otras cosas, esto previene que tablas de la base de datos y otros ficheros como `/etc/passwd' puedan ser destruidos. La sentencia SELECT ... INTO OUTFILE está pensada para permirtir un volcado muy rápido de una tabla en la máquina del servidor. Si se quiere crear el fichero resultado en algún otro host, no se puede usar SELECT ... INTO OUTFILE. En ese caso se debe usar en su lugar algún otro programa en el cliente como mysql -e "SELECT ..." > outfile en el ordenador cliente para generar el fichero. SELECT ... INTO OUTFILE es el complemento de LOAD DATA INFILE; la sintaxis para la parte export_options de la sentencia es la misma que para las claúsulas FIELDS y LINES que se usan con la sentencia LOAD DATA INFILE. FIELDS SCAPED BY controla el modo en que se escriben los caracteres especiales. Si el carácter de FIELDS ESCAPED BY no es vacío, se usará como prefijo para los siguientes caracteres en la salida:
  
  • El carácter ESCAPED BY.
  • El carácter FIELDS [OPTIONALLY] ENCLOSED BY.
  • El primer carácter de los valores FIELDS TERMINATED BY y LINES TERMINATED BY.
  • ASCII 0 (que actualmente se escribe seguido del carácter de escape ASCII `0', no un byte de valor cero.
  Si el caácter FIELDS ESCAPED BY se deja vacío, no se escapa ningún carácter y NULL se muestra como NULL, no \N. Probablemente no sea una buena idea especificar un carácter de escape vacío, sobre todo si existen valores de columnas en los datos que contengan cualquiera de los caracteres de la lista dada. El motivo de esto es que que se debe escapar cualquier carácter FIELDS TERMINATED BY, ESCAPED BY o LINES TERMINATED BY para que sea posible leer el fichero más tarde. El carácter ASCII NUL se escapa para que sea más fácil visualizarlo. Como el fichero resultante no tiene que seguir la sintaxis SQL, no es necesario escapar nada más. He aquí un ejemplo para obtener un fichero en formato de valores separados con comas usado por muchos programas:
  

  SELECT a,b,a+b INTO OUTFILE "/tmp/result.text"
  FIELDS TERMINATED BY ',' OPTIONALLY ENCLOSED BY '"'
  LINES TERMINATED BY "\n"
  FROM test_table;

• Si se usa INTO DUMPFILE en lugar de INTO OUTFILE, MySQL sólo escribirá una fila en el fichero, sin tabulaciones o terminadores y sin realizar ningún proceso de escapado. Esto es práctico si se quiere almacenar un valor BLOB en un fichero.
• Nota: Cualquier fichero creado por INTO OUTFILE y INTO DUMPFILE debe tener permiso de escritura para todos los usuarios en el servidor. El motivo es que el servidor MySQL no puede crear un fichero cuyo dueño sea alguien diferente que el usuario que hace la consulta (nunca se debe ejecutar MySQL como root). De modo que el fichero debe tener permiso de escritura para todo el mundo para que se pueda manejar su contenido.
• Una cláusula PROCEDURE nombra a un procedimiento que debe procesar los datos en el conjunto de resultados.
• Si se usa FOR UPDATE en un proceso de almacenamiento con bloqueo de página o de filas, las filas examinadas estarán bloquedas para escritura hasta el final de la operación actual. Usando IN SHARE MODE activa el bloqueo de compartir que evita que otras transacciones puedan actualizar o borrar las filas examinadas.

A continuación de la palabra clave SELECT, se pueden añadir determinadas opciones que afectan al funcionamiento de la sentencia.

Las opciones ALL, DISTINCT y DISTINCTROW especifican si las filas duplicadas deben ser devueltas. Si no se da ninguna de estas opciones, por defecto se usa ALL (se devuelven todas las filas coincidentes). DISTINCT y DISTINCTROW son sinónimos y especifican que las filas duplicadas en el conjunto de resultados deben ser eliminadas.

HIGH_PRIORITY, STRAIGHT_JOIN y las opciones que empiezan con SQL_ son extensiones MySQL al SQL estándar.

HIGH_PRIORITY dará a SELECT mayor prioridad que a sentencias que actualicen una tabla. Sólo se debe usar para consultas que sean muy rápidas y deban ser hechas inmediatamente. Una consulta SELECT HIGH_PRIORITY que se realice mientras la tabla esté bloqueada para lectura se realizará aunque exista una sentencia de actualización que esté esperando a que la table deje de estar bloqueada. HIGH_PRIORITY no se puede usar con sentecias SELECT que sean parte de una UNION.

STRAIGHT_JOIN fuerza el optimizador a unir tablas en el orden en que han sido listadas en la cláusula FROM. Se puede usar para mejorar la velocidad de una consulta si el optimizador une las tablas en un orden no óptimo. Consultar EXPLAIN. STRAIGHT_JOIN también puede ser usado en la lista de table_references. Ver JOIN

SQL_BIG_RESULT puede ser usada con GROUP BY o DISTINCT para informar al optimizador que el conjunto resultados puede contener muchas filas. En ese caso, MySQL podrá usar directametne tablas temporales en disco si es necesario. MySQL puede también, en este caso, optar por ordenar una tabla temporal con una clave dentro de los elementos GROUP BY.

SQL_BUFFER_RESULT fuerza que el resultado sea colocado en una tabla temporal. Esto ayuda a MySQL a librerar bloqueos en tablas más rápidamente y ayuda en casos donde toma mucho tiempo en enviar los datos al cliente.

SQL_SMALL_RESULT, puede usarse con GROUP BY o DISTINCT para informar al optimizador que el resultado será pequeño. En ese caso, MySQL usa tablas temporales rápidas para almecenar la tabla resultado en lugar de usar ordenamiento. A partir de MySQL 3.23 esto normalmente no es necesario.

SQL_CALC_FOUND_ROWS (versión 4.0.0 y siguientes) indica a MySQL que calcule cuántas filas contendrá el conjunto de resultados, ignorando cualquier cláusula LIMIT. El número de filas puede recuperarse con SELECT FOUND_ROWS(). Con versiones anteriores a la 4.1.0 esto no funcionará junto con LIMIT 0, ya que está optimizado de modo que regrese instantaneamente (resultando un número de filas igual a cero).

SQL_CACHE dice a MySQL que almacene el resultado de la consulta en un caché si se usa un valor 2 o DEMAND para QUERY_CACHE_TYPE. Para una consulta que use UNION o subconsultas, esta opción tendrá efecto al ser usada en cualquier SELECT de la consulta.

SQL_NO_CACHE indica a MySQL que no almacene el resultado de la consulta en el caché de consulta. Para una consulta que use UNION o subconsultas, esta opción tendrá efecto al ser usada en cualquier SELECT de la consulta.

START TRANSACTION COMMIT ROLLBACK

Por defecto, MySQL se ejecuta en modo autocommit. Esto significa que tan pronto como se ejecuta una sentencia se actualiza (modifica) la tabla, MySQL almacenará la actualización en disco.

Si se están usando tablas de transacción segura (como InnoDB o BDB), se puede poner MySQL en modo no-autocommit con el comando siguiente:

SET AUTOCOMMIT=0

Después de desconectar el modo autocommit asignando cero a la variable AUTOCOMMIT, se debe usar COMMIT para almecenar los cambios en disco o ROLLBACK si se quieren ignorar los cambios hechos desde el principio de la transacción.

Si se quiere desactivar el modo autocommit para una serire de sentencias, se puede usar una sentencia START TRANSACTION:

START TRANSACTION;
SELECT @A:=SUM(salary) FROM table1 WHERE type=1;
UPDATE table2 SET summmary=@A WHERE type=1;
COMMIT;

Se puede usar BEGIN y BEGIN WORK en lugar de START TRANSACTION para iniciar una transacción. START TRANSACTION fue añadido en MySQL 4.0.11; es la sintaxis SQL-99 y es el modo recomendado para empezar una transacción. BEGIN y BEGIN WORK están disponibles desde MySQL 3.23.17 y 3.23.19, respectivamente.

Si no se están usando tablas de transacción segura, cualquier cambio será almacenado inmediatamente, independientemente del estado del modo autocommit.

Si se usa una sentencia ROLLBACK después de actualizar una tabla no transaccional, se obtendrá un error (ER_WARNING_NOT_COMPLETE_ROLLBACK) como un aviso. Todas las tablas de transacción segura serán restauradas, pero cualquier tabla de transacción no segura no cambiará.

Si se usar START TRANSACTION o SET AUTOCOMMIT=0, se debe usar el diario binario MySQL para copias de seguridad en lugar del antigui diario de actualización. Las transacciones se almacenan en el diario binario de una vez, después de COMMIT, para asegurar que las transacciones que se han rebobinado no se almacenen.

Se puede modificar el nivel de aislamiento para transacciones con SET TRANSACTION ISOLATION LEVEL.

GRANT REVOKE

GRANT priv_type [(column_list)] [, priv_type [(column_list)]] ...
   ON {tbl_name | * | *.* | db_name.*}
   TO user [IDENTIFIED BY [PASSWORD] 'password']
       [, user [IDENTIFIED BY [PASSWORD] 'password']] ...
   [REQUIRE
       NONE |
       [{SSL| X509}]
       [CIPHER 'cipher' [AND]]
       [ISSUER 'issuer' [AND]]
       [SUBJECT 'subject']]
   [WITH [GRANT OPTION | MAX_QUERIES_PER_HOUR count |
                         MAX_UPDATES_PER_HOUR count |
                         MAX_CONNECTIONS_PER_HOUR count |
                         MAX_USER_CONNECTIONS count]]

REVOKE priv_type [(column_list)] [, priv_type [(column_list)]] ...
   ON {tbl_name | * | *.* | db_name.*}
   FROM user [, user] ...

REVOKE ALL PRIVILEGES, GRANT OPTION FROM user [, user] ...

Las sentencias GRANT y REVOKE permiten a los administradores del sistema crear cuentas de usuario MySQL y conceder y revocar derechos de esas cuentas. GRANT y REVOKE están disponibles a partir de MySQL 3.22.11. Para versiones anteriores de MySQL, estas sentencias no hacen nada.

La información sobre cuentas MySQL se almacena en las tablas de la base de datos mysql. Esta base de datos y el control de acceso se describen en detalle en la sección 5 "Database Administration", que se puede consultar para detalles adicionales.

Los privilegios pueden ser concedidos en varios niveles:

Nivel global

Los privilegios globales se aplican a todas las bases de datos de un servidor dado. Estos privilegios se almacenan en la tabla mysql.user. GRANT ALL ON *.* y REVOKE ALL ON *.* concenden y revocan sólo privilegios globales.

Nivel de base de datos

Los privilegios de base de datos se aplican a todos los objetos en una base de datos dada. Estos privilegios se almacenan en las tablas mysql.db y mysql.host. GRANT ALL ON db_name.* y REVOKE ALL ON db_name.* conceden y revocan sólo privilegios de base de datos.

Nivel de tabla

Los privilegios de tabla se aplican a todas las columnas de una tabla dada. Estos privilegios se almacenan en la tabla mysql.tables_priv. GRANT ALL ON db_name.tbl_name y REVOKE ALL ON db_name.tbl_name conceden y revocan únicamente privilegios de tabla.

Nivel de columna

Los privilegios de columna se aplican a una columna individual en una tabla dada. Estos privilegios se almacenan en la tabla mysql.columns_priv. Cuando se usa REVOKE, se deben especificar las mismas columnas que cuando se concedieron los privilegios.

Nivel de rutina

Los privilegios CREATE ROUTINE, ALTER ROUTINE, EXECUTE y GRANT se aplican a rutinas almacenadas. Pueden ser concedidos en los niveles global y de base de datos. Además, excepto para CREATE ROUTINE, estos privilegios pueden ser concedidos en el nivel de rutina para rutinas individuales y se almacenan en la tabla mysql.procs_priv.

Para hacer más sencillo revocar todos los privilegios, MySQL 4.1.2 ha añadido la siguiente sintaxis, que elimina todos los privilegios de los niveles de global, de base de datos, tabla y columna para los usuarios nombrados:

mysql> REVOKE ALL PRIVILEGES, GRANT OPTION FROM user [, user] ...

Antes de la versión 4.1.2 de MySQL, no es posible eliminar todos los privilegios de una vez. Se necesitan dos sentencias:

mysql> REVOKE ALL PRIVILEGES ON *.* FROM user [, user] ...
mysql> REVOKE GRANT OPTION ON *.* FROM user [, user] ...

Para las sentencias GRANT y REVOKE, se puede usar cualquiera de los siguientes valores para priv_type:

Privilegio	Significado
ALL [PRIVILEGES]	Activa todos los privilegios excepto GRANT OPTION.
ALTER	Permite el uso de ALTER TABLE.
CREATE	Permite el uso de CREATE TABLE.
CREATE ROUTINE	Crear rutinas almacenadas.
CREATE TEMPORARY TABLES	Permite el uso de CREATE TEMPORARY TABLE.
CREATE VIEW	Permite el uso de CREATE VIEW.
DELETE	Permite el uso de DELETE.
DROP	Permite el uso de DROP TABLE.
EXECUTE	Permite al usuario ejecutar procedimientos almacenados.
FILE	Permite el uso de SELECT ... INTO OUTFILE y LOAD DATA INFILE.
INDEX	Permite el uso de CREATE INDEX y DROP INDEX.
INSERT	Permite el uso de INSERT.
LOCK TABLES	Permite el uso de LOCK TABLES en tablas sobre las que ya se posea el privilegio SELECT.
PROCESS	Permite el uso de SHOW FULL PROCESSLIST.
REFERENCES	No implementado.
RELOAD	Permite el uso de FLUSH.
REPLICATION CLIENT	Permite al usuario preguntar dónde estan el los servidores esclavo o maestro.
REPLICATION SLAVE	Necesario para la replicación esclava (para leer eventos del diario binario desde el maestro).
SELECT	Permite el uso de SELECT.
SHOW DATABASES	La sentencia SHOW DATABASES muestra todas las bases de datos.
SHOW VIEW	Permite el uso de SHOW CREATE VIEW.
SHUTDOWN	Permite el uso del apagado de mysqladmin shutdown.
SUPER	Permite el uso de las sentencias CHANGE MASTER, KILL, PURGE MASTER LOGS y SET GLOBAL, el comando depurador de mysqladmin debug; permite conectar (una vez) aunque se haya alcanzado el número de conexiones max_connections.
UPDATE	Permite el uso de UPDATE.
USAGE	Sinónimo de "sin privilegios".
GRANT OPTION	Permite conceder privilegios.

Los privilegios CREATE TEMPORARY TABLES, EXECUTE, LOCK TABLES, REPLICATION CLIENT, REPLICATION SLAVE, SHOW DATABASES y SUPER fueron añadidos en MySQL 4.0.2. (EXECUTE no estará activo hasta MySQL 5.0.3.) CREATE VIEW y SHOW VIEW se añadirán en MySQL 5.0.1. CREATE ROUTINE y ALTER ROUTINE en MySQL 5.0.3. Para usar estos privilegios cuando se actualice a partir de una versión anterior de MySQL que no los tenga, se deben actualizar las tablas de concesiones.

El privilegio REFERENCES no se usa actualmente.

En versiones más antiguas de MySQL que no tienen el privilegio SUPER, hay que especificar el privilegio PROCESS en su lugar.

USAGE se puede usar cuando se quiere crear un usuario que no tenga privilegios.

Usar SHOW GRANTS para determinar qué privilegios tiene una cuenta.

Se pueden asignar privilegios globales mediante el uso de la sintaxis ON *.* o privilegios de base de datos mediante la sintaxis ON db_name.*. Si se especifica ON * y se tiene seleccionada una base de datos por defecto, los privilegios se conceden a esa base de datos. (Cuidado: si se especifica ON * y no se tiene ninguna base de datos seleccionada por defecto, los privilegios se conceden globalmente.)

Los privilegios EXECUTION, FILE, PROCESS, RELOAD, REPLICATION CLIENT, REPLICATION SLAVE, SHOW DATABASES, SHUTDOWN y SUPER son privilegios administrativos que sólo pueden ser concedidos de forma global (usando la sintaxis ON *.*).

Otros privilegios pueden ser concedidos globalmente o en niveles más específicos.

Los únicos valores priv_type que se pueden especificar para una tabla son SELECT, INSERT, UPDATE, DELETE, CREATE, DROP, GRANT OPTION, INDEX y ALTER.

Los únicos valores priv_type que se pueden especificar para una columna (esto es, cuando se usa una cláusula column_list) son SELECT, INSERT y UPDATE.

Los únicos valores priv_type que se pueden especificar en el nivel de rutina son ALTER ROUTINE, EXECUTE y GRANT. CREATE ROUTINE no es un privilegio de nivel de rutina porque se debe tener este privilegio para que sea posible crear una rutina en primer lugar.

Para los nilveles global, de base de datos, tabla y rutina, GRANT ALL sólo asigna privilegios que existan en el nivel en que se están concediendo. Por ejemplo, si se usa GRANT ALL ON db_name.*, que es una sentencia de nivel de base de datos, ningún privilegio exclusivo del nivel global, como FILE será concedido.

Para privilegios de nivel de columna (esto es, cuando se especifica column_list), se deben nombrar los privilegios a conceder explícitamente. No se puede usa ALL como especificador de privilegio.

MySQL permite conceder privilegios de nivel de base de datos aunque la base de datos no exista, para hacer más sencilla la preparación de una base de datos para su uso. Sin embargo, MySQL no permite actualmente conceder privilegios a nivel de tabla o columna si la tabla no existe. De forma similar, no se pueden conceder privilegios de nivel de rutina a procedimientos que no existan.

MySQL no revoca ningún privilegio automáticamente aunque se elimine una tabla o una base de datos. Si se elimina una rutina y se han concedido privilegios de nivel de rutina para ella, estos serán revocados.

Nota: los comodines '_' y '%' están permitidos cuando se especifican nombres de bases de datos en sentencias GRANT que concedan privilegios en los niveles global o de base de datos. Esto significa, por ejemplo, que si se quiere usar un carácter '_' como parte de un nombre de base de datos, se debe especificar como '\_' en la sentencia GRANT, para prevenir que el usuario al que se están concediendo pueda acceder a otras bases de datos que coincidan con el patrón definido por el comodín; por ejemplo, GRANT ... ON `foo\_bar`.* TO ....

Para albergar derechos concedidos a usuarios para máquinas arbitrarias, MySQL soporta la especificación para el valor de usuario en el formato user_name@host_name. Si un nombre de usuario user_name o de máquina host_name es un valor legal como identificador sin entrecomillar, no será necesario entrecomillarlo. Sin embargo, las comillas serán necesarias para especificar una cadena user_name que contenga caracteres especiales (como '-'), o una cadena de host_name que contenga caracteres especiales o caracteres comodín (como '%'); por ejemplo, 'test-user'@'test-hostname'. Hay que entrecomillar el nombre de usuario y el de la máquina separadamente.

Se pueden especificar comodines en el nombre de máquina. Por ejemplo, user_name@'%.loc.gov' se aplica a user_name para cualquier máquina en el dominio loc.gov y user_name@'144.155.166.%' se aplica a user_name para cualquier máquina en la clase C subred 144.155.166.

El formato simplificado user_name es sinónimo de user_name@'%'.

MySQL no soporta comodines en nombres de usuario. Los usuarios anónimos se definen mediante la inserción de entradas con User='' en la tabla mysql.user o creando un usuario con un nombre vacío con la sentencia GRANT:

mysql> GRANT ALL ON test.* TO ''@'localhost' ...

Cuando se especifican valores entre comillas para base de datos, tablas, columnas y nombres de rutina como identificadores, se usan tildes a izquieda ('`'). Los nombres de máquina, de usuario y contraseñas como cadenas, se usan apóstrofes (''').

Aviso: si se permite la conexión al servidor MySQL de usuarios anónimos, también se deben conceder privilegios a todos los usuarios locales como user_name@localhost. En caso contrario, se usará la cuenta del usuario anónimo para la máquina local en la tabla mysql.user cuando usuarios con nombre intenten conectarse al servidor MySQL desde la máquina local. (Esta cuenta de usuario anónimo se crea durante la instalación de MySQL.)

Se puede determinar si esto se aplica a cada caso mediante la ejecución de la siguiente sentencia:

mysql> SELECT Host, User FROM mysql.user WHERE User='';

Si se quiere borrar la cuenta de usuario anónimo local para evitar el problema descrito, usar estas sentencias:

mysql> DELETE FROM mysql.user WHERE Host='localhost' AND User='';
mysql> FLUSH PRIVILEGES;

GRANT soporta nombres de máquina de hasta 60 caracteres. Los nombres de base de datos, tabla, columna y rutina pueden tener hasta 64 caracteres. Los nombres de usuario hasta 16 caracteres.

Los privilegios para una tabla o columna se forman aditivamente con el O lógico de los privilegios de cada uno de los cuatro niveles de provilegios. Por ejemplo, si la tabla mysql.user especifica que un usuario tiene un privilegio global SELECT, el privilegio no puede ser denegado por una entrada en el nivel de base de datos, tabla o columna.

Los privilegios para una columna se pueden calcular de este modo:

global privileges
OR (database privileges AND host privileges)
OR table privileges
OR column privileges

En la mayoría de los casos, sólo se conceden privilegios a un usuario en uno de los niveles de privilegio, de modo que la vida no suele tener esta complicación.

Si se conceden privilegios para una combinación de usuario/máquina que no existe en la tabla mysql.user, se añade una entrada y se conserva hasta que se elimina con una sentencia DELETE. En otras palabras, GRANT puede crear entradas en la tabla de usuarios, pero REVOKE no las eliminará; se debe hacer explícitamente usando DROP USER o DELETE.

A partir de MySQL 3.22.12, si se crea un nuevo usuario o si se posee privilegios globales, la contraseña del usuario se asigna con la contraseña especificada por la cláusula IDENTIFIED BY, si se proporciona una. Si el usuario tiene una contraseña, se remplaza con la nueva.

Aviso: si se crea un nuevo usuario pero no se especifica una cláusula IDENTIFIED BY, el usuario no tiene contraseña. Esto es inseguro. A partir de MySQL 5.0.2, se puede activar el modo SQL NO_AUTO_CREATE_USER para evitar que GRANT cree nuevos usuarios si de otro modo los haría, a no ser que se proporcione una contraseña en IDENTIFIED BY.

Las contraseñas también se pueden asignar mediante la sentencia SET PASSWORD.

En la cláusula IDENTIFIED BY, la contraseña puede ser proporcionada como un valor de contraseña literal. No es necesario usar la función PASSWORD() como sí lo es para la sentencia SET PASSWORD. Por ejemplo:

GRANT ... IDENTIFIED BY 'mypass';

Si no se quiere enviar la contraseña en texto claro y se conoce el valor que se devuelve por la función PASSWORD() para la contraseña, se puede especificar tal valor precedido por la palabra clave PASSWORD:

GRANT ... IDENTIFIED BY PASSWORD '*6C8989366EAF75BB670AD8EA7A7FC1176A95CEF4';

En un programa C, se puede obtener ese valor mediante el uso de la función del API C make_scrambled_password().

Si se conceden privilegios para una base de datos, se crea una entrada en la tabla mysql.db si es necesario. Si todos los privilegios para una base de datos se eliminan con REVOKE, esa estrada será eliminada.

Si un usuario no tiene privilegios para una tabla, el nombre de la tabla no se muestra cuando el usuario pide una lista de tablas (por ejemplo, con una sentencia SHOW TABLES).

El privilegio SHOW DATABASES permite a una cuenta ver los nombres de bases de datos mediante la sentencia SHOW DATABASES. Las cuentas que no tienen este privilegio sólo ven las bases de datos para las que tienen algún privilegio, y no pueden usar la sentencia en ningún caso si el servidor fue arrancado con la opción --skip-show-database.

La cláusula WITH GRANT OPTION proporciona al usuario la oportunidad de dar a otros usuarios cualquier privilegio que que éste tenga en el nivel de privilegios especificado. Se debe ser cuidadoso con a quien se le da el privilegio GRANT OPTION, porque dos usuarios con privilegios diferentes pueden unirlos.

No se puede conceder a otro usuario un privilegio que no se posee; el privilegio GRANT OPTION permite dar sólo aquellos privilegios que se poseen.

Hay que saber que cuando se concede a un usuario el privilegio GRANT OPTION en un nivel particular, cualquier privilegio que posea el usuario (o que se le conceda en el fututo) en ese nivel, también se puede conceder por ese usuario. Dupongamos que se concede a un usuario el privilegio INSERT en una base de datos. Si se concede a continuación el privilegio SELECT en la base de datos y se especifica WITH GRANT OPTION, el usuarui puede dar a otros no sólo el privilegio SELECT, sino también el INSERT. Si a continuación se concede el privilegio UPDATE al usuario en la base de datos, puede conceder a otros los privilegios INSERT, SELECT y UPDATE.

No se deben conceder privilegios ALTER a un usuario normal. Si se hace, el usuario puede intentar transtornar el sistema de privilegios mediante el renombrado de tablas.

Las opciones MAX_QUERIES_PER_HOUR count, MAX_UPDATES_PER_HOUR count y MAX_CONNECTIONS_PER_HOUR count son nuevas en MySQL 4.0.2. Sirven para limitar el número de consultas, actualizaciones y entradas que un usuario puede realizar durante una hora. Si el contador se pone a 0 (el valor por defecto), significa que no hay límite para ese usuario.

La opción MAX_USER_CONNECTIONS count es nueva en MySQL 5.0.3. Limita el número máximo de conexiones simultáneas que puede hacer la cuenta. Si count es 0 (valor por defecto), la variable de sistema max_user_connections determina el número de conexiones simultáneas para la cuenta.

Nota: para especificar cualquiera de estas opciones de limitación de recursos para un usuario sin que se afecten los prvilegios ya existextentes, usar GRANT USAGE ON *.* ... WITH MAX_....

MySQL puede verificar los atributos de certificado X509 además de la autentificación habitual que se basa en nombre de usuario y contraseña. Para especificar opciones relacionadas con SSL para una cuenta MySQL, usar la cláusula REQUIRE para la sentencias GRANT.

Existen distintas posibilidades para limitar tipos de conexión para una cuenta:

• Si una cuenta no tiene los requerimientos SSL o X509, se permiten conexiones sin encriptar si el nombre de usuario y contraseña son válidos. Sin embargo, las conexiones encriptadas también se pueden usar en la opción del cliente, si éste tiene el certificado apropiado y los ficheros de clave.
• La opción REQUIRE SSL dice al servidoe que permita sólo conexiones encriptadas SSL para la cuenta. Hay que tener en cuenta que esta opción puede ser omitida si existe cualquier registro de control de acceso que permita conexiones no SSL.
  

  mysql> GRANT ALL PRIVILEGES ON test.* TO 'root'@'localhost'
     -> IDENTIFIED BY 'goodsecret' REQUIRE SSL;

• REQUIRE X509 significa que el cliente debe tener un certificado válido pero que el certificado exacto, emisor y condición no importan. El único requisito es que debe ser posible verificar su firma con uno de los certificados CA.
  

  mysql> GRANT ALL PRIVILEGES ON test.* TO 'root'@'localhost'
     -> IDENTIFIED BY 'goodsecret' REQUIRE X509;

• REQUIRE ISSUER 'issuer' pone la restricción en los intentos de conexión de que el cliente debe presentar un certificado X509 válido emitido por el CA 'issuer'. Si el cliente presenta un certificado que es válido pero tiene un emisor diferente, el servidor rechaza la conexión. El uso de certificados X509 siempre implica encriptado, de modo que la opción SSL es innecesaria.
  

  mysql> GRANT ALL PRIVILEGES ON test.* TO 'root'@'localhost'
     -> IDENTIFIED BY 'goodsecret'
     -> REQUIRE ISSUER '/C=FI/ST=Some-State/L=Helsinki/
        O=MySQL Finland AB/CN=Tonu Samuel/Email=tonu@example.com';

  Notar que el valor ISSUER debe ser introducido como una única cadena.
• REQUIRE SUBJECT 'subject' pone otra restricción en los intentos de conexión, la de que el cliente debe presentar un certificado válido X509 con la condición 'subject' en él. Si el cliente presenta un certificado válido pero que tiene una condición diferente, el servidor rechaza la conexión.
  

  mysql> GRANT ALL PRIVILEGES ON test.* TO 'root'@'localhost'
  
     -> IDENTIFIED BY 'goodsecret'
     -> REQUIRE SUBJECT '/C=EE/ST=Some-State/L=Tallinn/
        O=MySQL demo client certificate/
        CN=Tonu Samuel/Email=tonu@example.com';

  Notar que el valor SUBJECT debe ser introducido como una única cadena.
• REQUIRE CIPHER 'cipher' es necesario para asegurar que se usa un cifrado lo bastante fuerte y claves lo suficientemente largas. SSL mismo puede ser débil si se usan algoritmos antiguos con claves de encriptado cortas. Usando esta opción, se puede preguntar por un método de cifrado concreto para permitir la conexión.
  

  mysql> GRANT ALL PRIVILEGES ON test.* TO 'root'@'localhost'
     -> IDENTIFIED BY 'goodsecret'
     -> REQUIRE CIPHER 'EDH-RSA-DES-CBC3-SHA';

Las opciones SUBJECT, ISSUER y CIPHER pueden combinarse en la cláusula REQUIRE así:

mysql> GRANT ALL PRIVILEGES ON test.* TO 'root'@'localhost'
   -> IDENTIFIED BY 'goodsecret'
   -> REQUIRE SUBJECT '/C=EE/ST=Some-State/L=Tallinn/
      O=MySQL demo client certificate/
      CN=Tonu Samuel/Email=tonu@example.com'
   -> AND ISSUER '/C=FI/ST=Some-State/L=Helsinki/
      O=MySQL Finland AB/CN=Tonu Samuel/Email=tonu@example.com'
   -> AND CIPHER 'EDH-RSA-DES-CBC3-SHA';

Notar que cada valor SUBJECT e ISSUER deben ser introducidos como una única cadena.

A partir de MySQL 4.0.4, la palabra clave AND es opcional entre las opciones REQUIRE.

El orden de las opciones no es importante, pero ninguna opción se puede especificar dos veces.

Cuando mysqld arranca, todos los privilegios se leen en memoria. Los privielgios de base de datos, tabla y columna tienen efecto en seguida, y los privilegios de nivel de usuario tienen efecto la vez siguiente que el usuario se conecte. Las modificaciones en las tablas de concesiones que se realicen usando GRANT o REVOKE se notifican al servidor inmediatamente. Si se modifican las tablas de concesiones manualmente (usando INSERT, UPDATE, etc), se debe ejectuar una sentencia FLUSH PRIVILEGES o ejecutar mysqladmin flush-privileges para indicar al servidor que recargue las tablas de concesiones.

Si se están usando privilegios de tabla o columna para un único usuario, el servidor examina los privilegios de tabla y columna para todos los usuarios y esto ralentiza MySQL un poco. De forma similar, si se limita el número de consultas, actualizaciones o conexiones para algunos usuarios, el servidor debe monitorizar esos valores.

Las mayores diferencias entre las versiones de GRANT de SQL estándar y de MySQL son:

• En MySQL, los privilegios están asociados con una combinación de usuario/contraseña y no sólo con un usuario.
• SQL estándar no tiene provilegios de nivel global o de base de datos, ni soporta todos los tipos de privilegio que soporta MySQL.
• MySQL no soporta los privilegios de SQL estándar TRIGGER o UNDER.
• Los privilegios de SQL estándar están estructurados de forma jerárquica. Si se elimina un usuario, todos los privilegios que tiene concedidos se revocan. Esto también es cierto en MySQL 5.0.2 y siguientes si se usar DROP USER. Antes de 5.0.2, los privilegios concedidos no son revocados automáticamente; deben ser revocados directamente.
• Con SQL estándar, cuando se elimina una tabla, todos los privilegios para la tabla son revocados. Con SQL estándar, cuando se revoca un privilegio, todos los privilegios concedidos basados en él son revocados también. En MySQL, los privilegios pueden ser eliminados sólo con la sentencia REVOKE explícita o mediante la manipulación de las tablas de concesiones de MySQL.
• En MySQL, si sólo se posee el privilegio INSERT en algunas de las columnas de una tabla, se pueden ejecutar sentecias INSERT en la tabla; las columnas para las que no se posee el privilegio INSERT serán asignadas a sus valores por defecto. SQL estádar requiere que se posea el privilegio INSERT en todas las columnas.

RESET

RESET reset_option [,reset_option] ...

El comando RESET se usa para limpiar el estado de varias operaciones del servidor. También actúa como una versión más fuerte del comando FLUSH.

Para ejecutar RESET, se debe tener el privilegio RELOAD.

reset_option puede tomar uno de los siguientes valores:

Opción	Descripción
MASTER	Borra todos los diarios binarios listados en el fichero de índices, reseteando el fichero de índices de diarios binarios para vaciarlo. Antes se llamaba FLUSH MASTER.
QUERY CACHE	Elimina todos los resultados de consulta del caché de consultas.
SLAVE	Hace que el proceso esclavo olvide su posición en los diarios binarios maestros. Antes se llamaba FLUSH SLAVE.

REPLACE

REPLACE [LOW_PRIORITY | DELAYED]
   [INTO] tbl_name [(col_name,...)]
   VALUES ({expr | DEFAULT},...),(...),...

O:

REPLACE [LOW_PRIORITY | DELAYED]
   [INTO] tbl_name
   SET col_name={expr | DEFAULT}, ...

O:

REPLACE [LOW_PRIORITY | DELAYED]
   [INTO] tbl_name [(col_name,...)]
   SELECT ...

REPLACE trabaja exactamente igual que INSERT, excepto que si existe algún registro viejo en la tabla que tenga el mismo valor que uno nuevo para un índice PRIMARY KEY o UNIQUE, el viejo se borra antes de que el nuevo sea insertado.

Hay que tener en cuenta que salvo que la tabla tenga una PRIMARY KEY o un índice UNIQUE, usar una sentencia REPLACE no tiene sentido. En ese caso es equivalente usar una sentencia INSERT, ya que no hay ningún índice que se pueda usar para determinar si una nueva fila duplica a otra.

Los valores para todas las columnas se toman de los valores especificados en la sentencia REPLACE. A cualquier columna perdida se le asigna su valor por defecto, justo lo mismo que ocurre con INSERT. No es posible referirse a los valores de la columna vieja y usarlos en la nueva. Podría parecer que era posible hacerlo en algunas versiones anteriores de MySQL, pero se trataba de un error que ha sido corregido.

Para poder usar REPLACE, se deben poseer los privilegios INSERT y DELETE para la tabla.

La sentencias REPLACE devuelve un contador para indicar el número de filas afectadas. Ese número es la suma de filas borradas e insertadas. Si el contador es 1 para un REPLACE de una única fila, la fila fue insertada y no se borró ninguna fila. Si el contador es mayor de 1, una o más de las viejas filas fue borrada antes de que la nueva fila fuese insertada. Es posible que una única fila reemplace a más de una fila vieja si la tabla contiene varios índices únicos y la nueva fila duplica valores de diferentes filas viejas en diferentes índices únicos.

El contador de filas afectadas hace sencillo determinar si REPLACE sólo ha añadido una fila o si ha reemplazado alguna fila: Compronar si el contador es 1 (añadida) o mayor (reeplazada).

Si se está usando el API C, el contador de filas afectadas se puede obtener usando la función mysql_affected_rows().

Actualmente, no es posible reemplazar en una tabla y seleccionar de la misma tabla en una subconsulta.

A continuación se muestra con más detalle el algoritmo que se usa (también se usa con LOAD DATA ... REPLACE):

1. Intenta insertar la nueva fila en la tabla.
2. Mientras la inserción falle porque ocurra un error de clave duplicada para una clave primaria o única:
1. Borrar de la tabla la fila conflictiva que que tenga el valor de clave duplicado.
2. Intentar la inserción de la nueva fila en la tabla otra vez.

REPAIR TABLE

REPAIR [LOCAL | NO_WRITE_TO_BINLOG] TABLE tbl_name[,tbl_name...]
  [QUICK] [EXTENDED] [USE_FRM]

REPAIR TABLE funciona sólo con tablas MyISAM y es lo mismo que ejecutar myisamchk -r table_name en la tabla.

Normalmente nunca se tendrá que ejecutar este comando, pero si ocurre un desastre es muy probable que se puedan recuperar todos los datos de una tabla MyISAM con REPAIR TABLE. Si las tablas están muy corruptas, se debe intentar encontrar el motivo, para eliminar la necesidad de usar REPAIR TABLE.

REPAIR TABLE repara una tabla posiblemente corrupta. El comando devuelve una tabla con las columnas siguientes:

Columna	Valor
Table	Nombre de tabla
Op	Siempre "repair" (reparar)
Msg_type	Uno de "status", "error", "info" o "warning" (estado, error, información o aviso)
Msg_text	El mensaje

La sentencia puede producir muchas filas de información para cada tabla reparada. La última fila será de estado y debe ser normalemente OK. Si no se obtiene un OK, se debe intentar reparar la tabla con myisamchk --safe-recover, ya que REPAIR TABLE aún no tiene implementadas todas las opciones de myisamchk. En un futuro cercano, será más flexible.

Si se usa QUICK, REPAIR TABLE intenta reparar sólo el árbol de índices.

Si se usa EXTENDED, MySQL creará el índice fila a fila en lugar de crear un índice de una vez mediante ordenamiento; esto puede ser mejor que ordenar en claves de longitud constante si se tienen claves CHAR largas que se comprimen bien. Este tipo de reparación se como si se usase myisamchk --safe-recover.

Desde MySQL 4.0.2, existe un modo USE_FRM para REPAIR. Hay que usarlo si el fichero '.MYI' se ha perdido o si su cabecera está corrupta. En este modo MySQL recreará la tabla, usando información del fichero '.frm'. Este tipo de reparación no se puede hacer con myisamchk.

Cuidado: si mysqld muere durante un REPAIR TABLE, es esencial que lo primero que se haga sea otro REPAIR en la tabla antes de ejecutar cualquier otro comando en ella. (Por supuesto, es siempre mejor arrancar con un backup). En el peor caso se puede obtener un fichero de índices limpio sin información sobre el fichero de datos y con el siguiente comando se sobrescribe el fichero de datos. No es probable, pero es posible.

Antes de MySQL 4.1.1, los comandos REPAIR no actualizaban el diario binario. Desde MySQL 4.1.1 sí se hace, salvo que se use la palabra opcional NO_WRITE_TO_BINLOG (o su alias LOCAL).