Las transacciones de bases de datos permiten agrupar sentencias (por ejemplo SQL) en

bloques, que van a ser ejecutados simultáneamente de tal forma que podamos evaluar si
alguna de las sentencias ha fallado y de ser así poder deshacer los cambios en el momento
sin alterar de forma alguna la base de datos.

¿ Como funcionan las transacciones MySQL ?

Cada transacción puede verse como una función, y dentro de ella puede haber tantas
instrucciones como sea necesario.

START TRANSACTION;
UPDATE users SET name='jan
UPDATE users SET name='jho
COMMIT; / ROLLBACK;

1 START TRANSACTION;
2 UPDATE users SET name='jane' WHERE id=1;
3 UPDATE users SET name='jhon' WHERE id=2;
4 COMMIT; / ROLLBACK;

En este caso tenemos dos sentencias, cada una de ellas para editar un registro, MySQL las
evalúa y las guarda en un estado temporal y posteriormente son ejecutadas o desechadas
con los comandos COMMIT o ROLLBACK.

Transacciones de base de datos con MySQL en PHP

Cuando trabajamos con PHP podemos hacer uso de sus funciones para implementar las
transacciones de bases de datos en nuestros proyectos. Veamos un pequeño ejemplo

Primero debemos crear la conexión a la base de datos

$conex = new mysqli("localhos

1 $conex = new mysqli("localhost", "root", "pass", "database");

Ahora digamos que en nuestra base de datos tenemos una tabla llamada “users” con varios
usuarios registrados. vamos a agregar un nuevo usuario y editar uno existente en la misma
transacción
 $conex->autocommit(false);

$conex->query("INSERT INTO u

1 $conex->autocommit(false);
2
3 $conex->query("INSERT INTO users (name) VALUES ('marcus')");
4
5 $conex->query("UPDATE users SET name = 'jane' WHERE 'id' = 39 ");
6
7 $conex->commit();

Al cambiar el autocommit a “false” estamos indicando que queremos enviar los cambios
de forma manual que es justo lo que hacemos al finall con commit().

Evaluando las transacciones

En el bloque anterior simplemente estamos ejecutando todas las transacciones sin importar
si una o varias de ellas hayan fallado, la ventaja de su uso radica justamente en la capacidad
de desechar todos los cambios en caso de que esto ocurra para evitar inconsistencias. vamos
a refactorizar un poco el código.

', $e->getMessage(), "\n";

1 $conex->autocommit(false);
2
3 try {
4 $conex->query("INSERT INTO users (name) VALUES ('marcus')");
5 $conex->query("UPDATE users SET name = 'jane' WHERE 'id' = 39 ");
6 $conex->commit();
7 } catch (Exception $e) {
8 $conex->rollback();
9 echo 'Something fails: ', $e->getMessage(), "\n";
10 }

De esta forma si se encuentra un problema en una de las sentencias se captura una

excepción y se hace rollback de la transacción de lo contrario se enviarán los cambios a la
base de datos.
ACID son las siglas de Atomicity, Consistency, Isolation y Durability (Atomicidad,
Consistencia, Aislamiento , Durabilidad)

 Atomicidad. Es la propiedad que asegura que la operación se ha realizado o no, y

por lo tanto ante un fallo del sistema no puede quedar a medias.
 Consistencia. Esta propiedad esta ligada a la integridad referencial, es decir solo se
pueden escribir datos válidos respetando los tipos de datos declarados y la
integridad referencial.
 Aislamiento. Asegura que una operación no puede afectar a otras. Con esto se
asegura que varias transacciones sobre la misma información sean independientes y
no generen ningún tipo de error.
 Durabilidad. Cuando se completa una transacción con éxito los cambios se vuelven
permanentes.

El ejemplo clásico de transacción es una transferencia bancaria, en la que quitamos saldo a

una cuenta y lo añadimos en otra. Si no somo capaces de abonar el dinero en la cuenta de
destino, no debemos quitarlo de la cuenta de origen.

Para implementar transacciones en MySQL hay que utilizar la versión 5.0.x y el motor de
almacenamiento InnoDB.

Una transacción tiene dos finales posibles, COMMIT (se ejecutan todas las instrucciones y
guardamos los datos) y ROLLBACK (se produce un error y no se guardan los cambios).
Por defecto, MySQL trae activado el modo autocommit, por lo que cuando se realiza una
transacción (INSERT, UPDATE o DELETE) esta se confirma automáticamente. Para
desactivar esta opción se debe ejecutar el siguiente comando (no recomendado):
> SET AUTOCOMMIT=0;
o también se puede desactivar para una serie de comandos utilizando START
TRANSACTION. (Esto es lo recomendado)
> START TRANSACTION;
> .....
> COMMIT;

Hay que tener en cuenta que al realizar una transacción SQL que cuando se realice un
INSERT, UPDATE o DELETE se generará un bloqueo sobre la tabla y que otros clientes
no pueden acceder esta para escribir. Pero si podrán realizar lecturas, en las que no podrán
ver los datos del primer cliente hasta que los mismos sean confirmados.
Cómo hacer copias de seguridad de una
base de datos MySQL
El método más utilizado para crear copias de seguridad de MySQL se basa en el uso del
comando mysqldump. Este comando se incluye dentro de las utilidades del propio servidor
MySQL, por lo que ya se instaló cuando instalaste MySQL. Para comprobar que dispones
de mysqldump, abre una consola de comandos y ejecuta lo siguiente:

$ mysqldump

# para comprobar la versión instalada

$ mysqldump --version
mysqldump Ver 10.XX Distrib 5.X.XX

Si se produce un error de tipo "command not found", es posible que no hayas instalado
MySQL correctamente o que tengas que indicar la ruta completa hasta donde se encuentre
el comando, como por ejemplo:

$ /usr/local/mysql/bin/mysqldump

Copia de seguridad básica

Ejecuta el siguiente comando para realizar una copia de seguridad completa de la base de
datos llamada NOMBRE_BASE_DE_DATOS. No olvides reemplazar TU_USUARIO y
TU_CONTRASEÑA por las credenciales que utilizas para acceder al servidor de base de datos:

$ mysqldump --user=TU_USUARIO --password=TU_CONTRASEÑA

NOMBRE_BASE_DE_DATOS > copia_seguridad.sql

Si por ejemplo el usuario es root, la contraseña también es root y la base de datos se llama
acme, el comando que debes ejecutar es el siguiente:

$ mysqldump --user=root --password=root acme > copia_seguridad.sql

Si por motivos de seguridad no quieres escribir la contraseña como parte del comando,
puedes reemplazar la opción --password=XX por -p. Al hacerlo, MySQL te pedirá que
escribas la contraseña a mano cada vez que realices una copia de seguridad:

$ mysqldump --user=root -p acme > copia_seguridad.sql

Enter password: *********

Recuperando una copia de seguridad

Las copias de seguridad sólo son útiles si se pueden recuperar fácilmente los datos cuando
se produce un error. Suponiendo que los datos a recuperar se encuentran en el archivo
copia_seguridad.sql, el comando que debes ejecutar para recuperar la información de la
base de datos es el siguiente:

$ mysql --user=TU_USUARIO --password=TU_CONTRASEÑA < copia_seguridad.sql

Observa cómo en este caso se ejecuta el comando mysql y no el comando mysqldump.

Utilizando los mismos datos que en el ejemplo anterior, el comando a ejecutar sería:

$ mysql --user=root --password=root < copia_seguridad.sql

En este comando no hace falta indicar el nombre de la base de datos que se está
recuperando, porque los archivos generados por mysqldump ya contienen esa información.
De hecho, al ejecutar este comando de recuperación se borra la base de datos original
y toda la información de sus tablas, para después insertar toda la información contenida
en el archivo copia_seguridad.sql.

Si la copia de seguridad la haces en una versión de MySQL moderna y la recuperación de

la información se realiza en una versión un poco antigua, es mejor que añadas la opción --
skip-opt al realizar la copia de seguridad, para desactivar algunas opciones modernas e
incompatibles:

$ mysqldump --user=TU_USUARIO --password=TU_CONTRASEÑA

--skip-opt NOMBRE_BASE_DE_DATOS > copia_seguridad.sql

Copias de seguridad de más de una base de datos

Normalmente el comando mysqldump se utiliza para realizar la copia de seguridad de una
única base de datos. No obstante, en ocasiones es necesario copiar varias bases de datos.
Para ello, utiliza la opción --databases e indica el nombre de todas las bases de datos
separados por un espacio en blanco:

$ mysqldump --user=TU_USUARIO --password=TU_CONTRASEÑA

--databases NOMBRE_BASE_DE_DATOS_1 NOMBRE_BASE_DE_DATOS_2
NOMBRE_BASE_DE_DATOS_3 > copia_seguridad.sql

Si lo que quieres es realizar una copia de seguridad de todas las bases de datos, utiliza en su
lugar la opción --all-databases:

$ mysqldump --user=TU_USUARIO --password=TU_CONTRASEÑA

--all-databases > copia_seguridad.sql
rear un nuevo usuario y otorgarle
permisos en MySQL
PostedDecember 3, 2014 350.7k views

¿Qué representa el color rojo?

Las líneas que necesiten ser personalizadas por el usuario serán marcadas con rojo en este
tutorial. El resto podrá ser copiado y pegado en su mayoría.

Acerca de MySQL

MySQL es un manejador de base de datos de código libre que atyda a los usuarios a
almacenar, organizar y recolectar datos. Tiene variedad de opciones para otorgar a
determinados usuarios permisos entre tablas y bases de datos, éste tutorial te dará una
pequeña introducción a algunas de estas opciones.

¿Cómo crear un nuevo usuario?

En la parte 1 del tutorial de MySQL, hicimos todas las ediciones como usuario root, con
acceso completo a todas las bases de datos. Como sea, en este caso hay mas restricciones
que pueden ser requeridas, hay formas de crear usuarios con persmisos personalizados.

Vamos empezando por crear un usuario nuevo desde la consola de MySQL:

CREATE USER 'nombre_usuario'@'localhost' IDENTIFIED BY 'tu_contrasena';

Lamentablemente, a este punto el nuevo usuario no tiene permisos para hacer algo con las
bases de datos. Por consecuencia si el usuario intenta identificarse (con la contraseña
establecida), no será capaz de acceder a la consola de MySQL.

Por ello, lo primero que debemos hacer es porporcionarle el acceso requerido al usuario con
la información que requiere.

GRANT ALL PRIVILEGES ON * . * TO 'nombre_usuario'@'localhost';

Los asteriscos en este comando hacen referencia a la base de datos y la tabla

(respectivamente) a la cual el nuevo usuario tendrá acceso; específicamente este comando
permite al usuario leer, editar, ejecutar y realizar todas las tareas en todas las bases de datos
y tablas.

Una vez que has finalizado con los permisos que deseas configurar para tus nuevos
usuarios, hay que asegurarse siempre de refrescar todos los privilegios.
FLUSH PRIVILEGES;

Tus cambios ahora surtirán efecto.

¿Cómo otorgar permisos de usuario diferentes?

Aquí está una pequeña lista del resto de los posibles permisos que los usuarios pueden
gozar.

 ALL PRIVILEGES: como mencionamos previamente esto permite a un usuario de

MySQL acceder a todas las bases de datos asignadas en el sistema.
 CREATE: permite crear nuevas tablas o bases de datos.
 DROP: permite eliminar tablas o bases de datos.
 DELETE: permite eliminar registros de tablas.
 INSERT: permite insertar registros en tablas.
 SELECT: permite leer registros en las tablas.
 UPDATE: permite actualizar registros seleccionados en tablas.
 GRANT OPTION: permite remover privilegios de usuarios.

Para proporcionar un permiso a usuario específico, puedes utilizar ésta estructura:

GRANT [permiso] ON [nombre de bases de datos].[nombre de tabla] TO

‘[nombre de usuario]’@'localhost’;

Si deseas darles acceso a cualquier base de datos o tabla, asegurate de insertar un asterisco
(8) en lugar del nombre de la base de datos o tabla.

Cada vez que tu actualizas o cambias permisos, asegúrate de refrescar los privilegios
mediante FLUSH PRIVILEGES;.

Si necesitas remover un permiso, la estructura es casi idéntica a la que los asigna:

REVOKE [permiso] ON [nombre de base de datos].[nombre de tabla] FROM

‘[nombre de usuario]’@‘localhost’;

Así como puedes borrar bases de datos con DROP, también puedes usar el comando DROP
para borrar usuarios:

DROP USER ‘usuario_prueba’@‘localhost’;

Para probar el nuevo usaurio, debes cerrar sesión escribiendo quit y volviendo a iniciar
sesión con éste comando en la consola:

mysql -u [nombre de usuario]-p

MySQL: cómo conceder y quitar privilegios en esta base
de datos
Advertencia

Es muy recomendable realizar siempre una copia de seguridad de las base de datos, siempre
que vayas a ejecutar cambios importantes en ella.

La función GRANT de MySQL es la utilizada para facilitar privilegios:

GRANT privilegios
ON base/tabla
TO usuario [IDENTIFIED by ´contraseña´]
[WITH GRANT OPTION];

La opción WITH GRANT OPTION facilita al usuario el poder de darle a otros usuarios
sus mismos privilegios.

Con la siguiente query darías todos los permisos (excepto WITH GRANT OPTION) a un
usuario sobre una base de datos especificada:

GRANT ALL ON BD.* TO USER@localhost IDENTIFIED BY "PASSWORD"

Para dar todos los permisos, incluido el WITH GRANT OPTION, debe de indicarse con
su opción pertinente:

GRANT ALL ON BD.* TO USER@localhost IDENTIFIED BY "PASSWORD" WITH GRANT

OPTION;

Cabe destacar que esto no es aconsejable, y es altamente inseguro ya que únicamente el

usuario administrador debería poder agregar o eliminar privilegios.

De la siguiente forma únicamente le darías permiso para realizar algunas querys sobre la
base de datos. Cabe destacar que el usuario no podría crear nuevas tablas ni nuevas bases
de datos:

GRANT select,insert,update,delete ON BD.* TO USER@localhost IDENTIFIED BY

"PASSWORD";

La función REVOKE es empleada para retirar privilegios a los usuarios. Su sintaxis es

muy similar a la de GRANT:
REVOKE privilegios
ON base/tabla
FROM usuario

De este modo quitarías todos los permisos del usuario.

REVOKE ALL ON BD.* from USER@localhost

En esta entrada vamos a ver cómo gestionar usuarios MySQL desde la línea de
comandos/shell de MySQL. Lo más básico que debemos saber al respecto es crear, borrar
y modificar los usuarios así como saber el modo de manejar y asignar o revocar los
privilegios que cada usuario va a tener respecto a las bases de datos instaladas en el
servidor.

La gestión de usuarios también se puede realizar desde herramientas gráficas y aplicaciones

web como por ejemplo phpMyAdmin o el administrador gráfico de MySQL, en este caso
vamos a lo que siempre tendremos a mano, la shell de MySQL.

Lo primero que debemos hacer es acceder a la shell de MySQL con un usuario que tenga
privilegios de administración, en este caso lo hacemos como root y desde el propio host por
línea de comandos:

# mysql -u root -p
Enter password: **********
Welcome to the MySQL monitor. Commands end with ; or \g.
Your MySQL connection id is 12
Server version: 5.1.73 Source distribution
Copyright (c) 2000, 2013, Oracle and/or its affiliates. All rights
reserved.
Oracle is a registered trademark of Oracle Corporation and/or its
affiliates. Other names may be trademarks of their respective
owners.
Type 'help;' or '\h' for help. Type '\c' to clear the current input
statement.
mysql>

Crear usuario MySQL con CREATE USER

El comando “CREATE USER” de MySQL nos va a permitir crear usuarios y asignarles
una contraseña con el parámetro “IDENTIFIED BY“. Más adelante veremos que este paso
lo podemos evitar utilizando directamente el comando “GRANT” para la creación del
usuario y asignación de privilegios en un único paso.

La sintaxis es la siguiente:

CREATE USER user [IDENTIFIED BY [PASSWORD] 'password']

Así pues, si quisieramos crear un usuario llamado “foo” y con clave “mipassword”
ejecutaríamos el siguiente comando:

mysql> CREATE USER foo IDENTIFIED BY 'mypassword';

Query OK, 0 rows affected (0.01 sec)

Tenemos la opción de especificar la contraseña con su valor en hash. Este valor debe ser
generado anteriormente con la función PASSWORD() de MySQL:

mysql> SELECT PASSWORD('mipassword');

+-------------------------------------------+
| PASSWORD('mipassword') |
+-------------------------------------------+
| *CEE870801502ACAD44FA46CA2CA4F58C2B721A67 |
+-------------------------------------------+
1 row in set (0.00 sec)

mysql> CREATE USER foo IDENTIFIED BY PASSWORD

'*CEE870801502ACAD44FA46CA2CA4F58C2B721A67';
Query OK, 0 rows affected (0.01 sec)

Eliminar usuario MySQL

Eliminar un usuario MySQL es sencillo, el comando a utilizar es “DROP USER” seguido
del usuario a eliminar:

mysql> DROP USER foo;

Query OK, 0 rows affected (0.00 sec)

Asignar privilegios al usuario con GRANT

Cuando creamos un usuario utilizando CREATE USER, efectivamente la creación es
satisfactoria, pero veréis que el usuario únicamente puede conectarse y visualizar ciertos
parámetros del servidor. La verdad es que podemos crear directamente los usuarios con el
comando GRANT y a la vez asignar los privilegios que queramos respecto a las bases de
datos del sistema. Básicamente GRANT asigna privilegios al usuarios indicado, y si no
existe lo crea.

La sintaxis y modo de uso del comando sería la siguiente:

GRANT ON privilegios TO 'usuario'@'host_de_conexion'

-> IDENTIFIED BY 'password' WITH GRANT OPTION;

En el siguiente ejemplo, asignamos todos los privilegios posibles al usuario “foo” (si no
existe se crea) sobre todas las bases de datos y tablas, para conexiones desde localhost
únicamente y además le concedemos el permiso GRANT para que tenga la opción de
asignar permisos a otros usuarios:

mysql> GRANT ALL PRIVILEGES ON *.* TO 'foo'@'localhost'

-> IDENTIFIED BY 'mipassword' WITH GRANT OPTION;

Los privilegios disponibles son los siguientes:

ALL PRIVILEGES, ALTER, ALTER ROUTINE, CREATE TABLE, CREATE

ROUTINE, CREATE TEMPORARY TABLES, CREATE USER (Permite utilizar
CREATE USER, DROP USER, RENAME USER, y REVOKE ALL PRIVILEGES),
CREATE VIEW, DELETE, DROP, EXECUTE, FILE, INDEX, INSERT, LOCK
TABLES, PROCESS, RELOAD, REPLICATION CLIENT, REPLICATION SLAVE,
SELECT, SHOW DATABASES, SHOW VIEW, SHUTDOWN, SUPER, UPDATE,
USAGE, GRANT OPTION.

En la documentación oficial de MySQL encontraréis información y detalle de cada

privilegio.

Recordad que el comando HELP de la shell de MySQL os mostrará la ayuda relativa a cada
comando. Para encontrar ayuda de GRANT usamos HELP GRANT y vemos que además
de la información relativa al comando aparecen varios ejemplos de uso:

mysql> HELP GRANT

[...]
CREATE USER 'jeffrey'@'localhost' IDENTIFIED BY 'mypass';
GRANT ALL ON db1.* TO 'jeffrey'@'localhost';
GRANT SELECT ON db2.invoice TO 'jeffrey'@'localhost';
GRANT USAGE ON *.* TO 'jeffrey'@'localhost' WITH MAX_QUERIES_PER_HOUR 90;
[...]

Como podéis observar, cuando los privilegios hacen referencia a bases de datos, tablas o
hosts distintos se ejecuta un comando por cada uno de ellos, no se puede englobar todo en
una única ejecución ya que se almacena en registros distintos dentro de la tabla de
privilegios.

Si quisieramos asignar privilegios a un usuario que va a conectar desde distintos hosts, lo

haríamos de modo individual, es decir:

mysql> GRANT ALL ON db1.* TO 'foo'@'host1';

mysql> GRANT ALL ON db1.* TO 'foo'@'host2';

Lo mismo para distintas bases de datos o tablas:

mysql> GRANT ALL ON db1.* TO 'foo'@'localhost';

mysql> GRANT ALL ON db2.* TO 'foo'@'localhost';
mysql> GRANT ALL ON db3.tabla1 TO 'foo'@'localhost';
mysql> GRANT ALL ON db4.tabla1 TO 'foo'@'localhost';

Para asignar un “wildcard” de hosts utilizamos el carácter %. Es decir, de este modo el

usuario puede conectar a MySQL desde cualquier host:

mysql> GRANT ALL ON db1.* TO 'foo'@'%';

Visualizar privilegios de un usuario con SHOW

GRANTS
El comando SHOW GRANTS sirve para visualizar en la salida estándar de la shell de
MySQL los privilegios asignados a un usuario:

mysql> SHOW GRANTS for 'foo'@'localhost';

 +-----------------------------------------------------------------------
--------+
| Grants for foo@localhost
|
+-----------------------------------------------------------------------
--------+
| GRANT ALL PRIVILEGES ON *.* TO 'foo'@'localhost' IDENTIFIED BY
PASSWORD '...' |
+-----------------------------------------------------------------------
--------+
1 row in set (0.00 sec)

Revocar privilegios al usuario con REVOKE

Para eliminar privilegios que previamente hemos asignado a un usuario MySQL con el
comando GRANT, utilizaremos el comando REVOKE. La sintaxis sería la siguiente:

REVOKE privilegios, GRANT OPTION FROM 'usuario'@'host';

La opción “GRANT OPTION” sólo es necesaria si el usuario ha sido configurado con el

privilegio “WITH GRANT OPTION”.

Al igual que a la hora de asignar los privilegios se realiza de forma individual por base de
datos, host, tabla, etc. A la hora de revocar es lo mismo:

mysql> SHOW GRANTS for 'foo'@'localhost';

+------------------------------------------------------------------------
--------+
| Grants for foo@localhost
|
+------------------------------------------------------------------------
--------+
| GRANT ALL PRIVILEGES ON *.* TO 'foo'@'localhost' IDENTIFIED BY PASSWORD
'*CEE' |
| GRANT SELECT ON `test`.* TO 'foo'@'localhost'
|
+------------------------------------------------------------------------
--------+
2 rows in set (0.00 sec)
mysql> SHOW GRANTS for 'foo'@'host1';
+------------------------------------------------------------------------
--------+
| Grants for foo@host1
|
+------------------------------------------------------------------------
--------+
| GRANT ALL PRIVILEGES ON *.* TO 'foo'@'host1' IDENTIFIED BY PASSWORD
'*CEE8707' |
+------------------------------------------------------------------------
--------+
1 row in set (0.01 sec)
Una vez visualizados los privilegios con el comando SHOW GRANTS, eliminamos los que
estimemos oportuno:

mysql> REVOKE SELECT ON test.* FROM 'foo'@'localhost';

Query OK, 0 rows affected (0.01 sec)

En el caso de ‘foo’@’localhost’ vemos que tiene todos los privilegios para todas las bases
de datos, en lugar de eliminar completamente esa entrada de privilegios podemos hacerla
más restrictiva, por ejemplo manteniendo todos los permisos excepto INSERT:

mysql> REVOKE INSERT ON *.* FROM 'foo'@'localhost';

Query OK, 0 rows affected (0.00 sec)

Y vemos como MySQL automáticamente elimina el privilegio INSERT y mantiene el

resto:

mysql> SHOW GRANTS for 'foo'@'%';

ERROR 1141 (42000): There is no such grant defined for user 'foo' on host
'%'
mysql> SHOW GRANTS for 'foo'@'localhost';
+------------------------------------------------------------------------
---+
| Grants for foo@localhost
|
+------------------------------------------------------------------------
---+
| GRANT SELECT, UPDATE, DELETE, CREATE, DROP, RELOAD, SHUTDOWN, PROCESS,
FILE, REFERENCES, INDEX, ALTER, SHOW DATABASES, SUPER,
CREATE TEMPORARY TABLES, LOCK TABLES, EXECUTE, REPLICATION SLAVE,
REPLICATION CLIENT, CREATE VIEW, SHOW VIEW, CREATE ROUTINE, ALTER
ROUTINE,
CREATE USER, EVENT, TRIGGER ON *.* TO 'foo'@'localhost' IDENTIFIED BY
PASSWORD
'*CEE870801502ACAD44FA46CA2CA4F58C2B721A67' |
+------------------------------------------------------------------------
---+
1 row in set (0.01 sec)

FLUSH PRIVILEGES
El comando “FLUSH PRIVILEGES” sirve para recargar la tabla de privilegios pero sólo
es necesario cuando se manipulan directamente las tablas de privilegios ejecutando
INSERT, DELETE, etc en lugar de usar los comandos GRANT y REVOKE:

mysql> FLUSH PRIVILEGES;

Query OK, 0 rows affected (0.01 sec)

Es decir, en los casos que he especificado en este artículo no es necesario utilizar este modo
de recargar los privilegios, sólo sería necesario si crearamos o eliminaramos los usuarios “a
mano” directamente sin los comandos específicos para ello de MySQL:
mysql> INSERT INTO user
-> VALUES('localhost','foo',mipassword'),
-> 'Y','Y','Y','Y','Y','Y','N','N','N','Y','Y','Y','Y','Y');