Guía de iniciación MySQL

1.  Empezando con MySQL

Contexto

MySQL es un servidor de base de datos popular que tiene distintas aplicaciones. SQL son las iniciales de Lenguaje de Consulta Estructurado (en inglés, (S)tructured (Q)uery (L)anguage), que es el lenguaje que utiliza MySQL para comunicarse con otros programas. Sobre ello, MySQL tiene sus propias funciones SQL extendidas que le añaden funcionalidad. En este documento veremos como realizar una instalación inicial, configurar la base de datos y las tablas, y como crear nuevos usuarios. Empecemos con la instalación.

Instalación de MySQL

Primero asegúrate de tener instalado MySQL en tu sistema. En caso de que necesites alguna funcionalidad específica de MySQL, por favor revisa si tienes los parámetros USE adecuados ya que estos ayudarán a ajustar la instalación a tus necesidades.

(Revisa las banderas USE disponibles)
# emerge --pretend --verbose mysql
(Instala MySQL)
# emerge mysql

Una vez completada la instalación, verás la siguiente nota:

You might want to run:
"emerge --config =dev-db/mysql-[version]"
if this is a new install.

Dado que esta es una nueva instalación, ejecuta el comando. Necesitarás presionar ENTER cuando se te solicite mientras se configura la base de datos MySQL. La configuración define la base de datos MySQL principal que contiene información administrativa como las bases de datos, tablas, usuarios, permisos y demás. La configuración recomienda que modifiques tu contraseña de super usuario lo antes posible. Definitivamente haremos eso, ya que de otra manera alguien más podría tener la oportunidad de hacerlo y hackear nuestra configuración por defecto del servidor MySQL.

(Reemplaza [version] con el número de la versión que acabas
de instalar.)
# emerge --config =dev-db/mysql-[version]
 * MySQL DATADIR is /var/lib/mysql
 * Press ENTER to create the mysql database and set proper
 * permissions on it, or Control-C to abort now...

   Preparing db table
   Preparing host table
   Preparing user table
   Preparing func table
   Preparing tables_priv table
   Preparing columns_priv table
   Installing all prepared tables

   To start mysqld at boot time you have to copy support-files/mysql.server
   to the right place for your system

   PLEASE REMEMBER TO SET A PASSWORD FOR THE MySQL root USER !
   To do so, issue the following commands to start the server
   and change the applicable passwords:
(Anota las siguientes 3 lineas)
   /etc/init.d/mysql start
   /usr/bin/mysqladmin -u root -h pegasos password 'new-password'
   /usr/bin/mysqladmin -u root password 'new-password'
   Depending on your configuration, a -p option may be needed
   in the last command. See the manual for more details.

(Alguna información MySQL no específica del ebuild ha sido
eliminada de aquí para mantener este documento tan conciso como sea
posible)

   * For security reasons you should set your MySQL root
   * password as soon as possible.

El guión de configuración ya ha impreso los comandos que necesitamos para definir nuestra contraseña de super usuario, así que ahora debemos ejecutarlos.

# /etc/init.d/mysql start * Re-caching dependency info (mtimes
 differ)...  * Starting mysqld (/etc/mysql/my.cnf) ...  [ ok ]
(Reemplaza new-password con la nueva contraseña)
# /usr/bin/mysqladmin -u root -h localhost password 'new-password'

Ahora puedes probar si la contraseña de administrador ha sido correctamente configurada al intentar ingresar al servidor MySQL:

$ mysql -u root -h localhost -p
Enter password:
Welcome to the MySQL monitor. Commands end with ; or \g.
Your MySQL connection id is 4 to server version: 4.0.25

Type 'help;' or '\h' for help. Type '\c' to clear the buffer.

mysql>

La opción -u define qué usuario está tratando de conectarse. La opción -h define a que máquina estás tratando de conectarte. Normalmente utilizarás localhost a menos que estés configurando un servidor remoto. Finalmente, -p indica al cliente mysql que vas a utilizar una contraseña para ingresar al sistema. Fíjate en el cursor mysql>. Aquí es donde escribirás tus comandos. Dado que hemos ingresado como super usuario, podemos empezar a configurar nuestra base de datos.

2.  Configurando la base de datos

Creando una base de datos

Hemos ingresado al sistema y tenemos el cursor mysql en pantalla. Primero, démosle una mirada a las bases de datos que tenemos actualmente. Para hacer eso, utilizamos el comando SHOW DATABASES.

mysql> SHOW DATABASES;
+----------+
| Database |
+----------+
| mysql    |
| test     |
+----------+
2 rows in set (0.09 sec)

Aunque ya existe una base de datos de prueba (test), vamos a crear la nuestra. Las bases de son creadas utilizando el comando CREATE DATABASE. Crearemos una llamada "gentoo".

mysql> CREATE DATABASE gentoo;
Query OK, 1 row affected (0.08 sec)

La salida nos permite ver que el comando ha sido ejecutado sin ningún error. En este caso, 1 fila ha sido modificada. Esto es una referencia a la base de datos principal de mysql, que contiene una lista de todas las bases de datos. No necesitarás preocuparte mucho acerca de los detalles técnicos. El último número se refiere a qué tan rápido se ha ejecutado la consulta. Podemos verificar que nuestra base de datos ha sido creada utilizando nuevamente el comando SHOW DATABASES.

mysql> SHOW DATABASES;
+----------+
| Database |
+----------+
| gentoo   |
| mysql    |
| test     |
+----------+
3 rows in set (0.00 sec)

Como podemos ver, nuestra base de datos ha sido creada. Para poder trabajar con ella creando nuevas tablas, necesitamos seleccionarla como nuestra base de datos actual. Esto lo podemos conseguir utilizando el comando USE. El comando USE recibe como argumento el nombre de la base de datos que quiere convertir en actual. Otra opción es definirla en la linea de comandos justo luego de la opción -D. Continuemos y cambiémonos a la base de datos gentoo.

mysql> USE gentoo;
Database changed

Y la base de datos actual es nuestra, previamente creada, base de datos gentoo. Ahora que la estamos utilizando, podemos empezar a crear algunas tablas y poner información en ellas.

3.  Trabajando con tablas en MySQL

Creando una tabla

En la estructura de MySQL, hay bases de datos, tablas, registros y campos. Las bases de datos reunen tablas, las tablas agrupan registros, estos a su vez almacenan campos, que son los encargados de conservar la información real. Esta estructura permite a los usuarios seleccionar cómo quieren acceder a su información. Hasta el momento hemos trabajado con bases de datos, ahora enfoquémonos en las tablas. Antes de nada, las tablas pueden ser mostradas de la misma manera que las bases de datos utilizando el comando SHOW TABLES. En este preciso momento no existen tablas en nuestra base de datos gentoo, como nos lo mostrará la salida del comando:

mysql> SHOW TABLES;
Empty set (0.00 sec)

Esto significa que tenemos que crear algunas tablas. Para poder hacer esto, utilizamos el comando CREATE TABLE. Sin embargo, este comando es un poco distinto del simple CREATE DATABASE. Este comando recibe una lista de parámetros. La forma es la siguiente:

CREATE TABLE [nombre_de_la_tabla] ([nombre_del_campo] [tipo_del_campo]([tamaño]));

nombre_de_la_tabla es el nombre de la tabla que deseas crear. En este caso crearemos una tabla llamada developers. Esta tabla contendrá el nombre del desarrollador, correo electrónico y trabajo. nombre_del_campo contendrá el nombre del campo. En este caso tenemos 3 requerimientos: nombre, correo electrónico y trabajo. El tipo_del_campo especifica que clase de información vas a almacenar ahí. Los distintos formatos disponibles puedes encontrarlos en la Página de los tipos MySQL para las columnas. En nuestro caso, utilizaremos el tipo de dato VARCHAR para todos nuestros campos. VARCHAR es uno de los tipos de datos más simples que existen para trabajar con cadenas. tamaño es cuanto de información tendrá almacenada cada campo. Utilizaremos 128, lo cual significa que el campo puede tener información VARCHAR de 128 bytes de longitud. Puedes pensar por ahora tranquilamente que son 128 caracteres, sin embargo hay una explicación un poco más técnica que el anterior sitio te dará. Ahora que sabemos como vamos a crear la tabla, hagámoslo.

mysql> CREATE TABLE developers ( name VARCHAR(128), email
VARCHAR(128), job VARCHAR(128));
Query OK, 0 rows affected(0.11 sec)

Parece que nuestra tabla ha sido creada sin problemas. Revisémoslo con el comando SHOW TABLES:

mysql> SHOW TABLES;
+------------------+
| Tables_in_gentoo |
+------------------+
| developers       |
+------------------+
1 row in set (0.00 sec)

Sí, esa es nuestra tabla. Sin embargo, parece no tener ninguna información sobre los tipos de campos que hemos configurado. Para ello, utilizamos el comando DESCRIBE (o si prefieres comandos más cortos DESC), que toma como argumento el nombre de la tabla. Veamos que información nos da de la tabla developers.

mysql> DESCRIBE developers;
+-------+--------------+------+-----+---------+-------+
| Field | Type         | Null | Key | Default | Extra |
+-------+--------------+------+-----+---------+-------+
| name  | varchar(128) | YES  |     | NULL    |       |
| email | varchar(128) | YES  |     | NULL    |       |
| job   | varchar(128) | YES  |     | NULL    |       |
+-------+--------------+------+-----+---------+-------+
3 rows in set (0.00 sec)

Esta salida muestra los distintos campos y sus tipos. También muestra algunos atributos extras que están más allá del ámbito de esta guía. Siéntete libre de consultar el Manual de Referencia MySQL para mayor información. Ahora tenemos una tabla con la cual trabajar. Sigamos adelante y probémosla.

Poblando nuestra base de datos MySQL

Se puebla una tabla (o se añade información) a través del comando INSERT. Al igual que el comando CREATE TABLE, posee un formato específico:

INSERT INTO tabla (col1, col2, ...) VALUES('valor1', 'valor2', ...);

Este comando se utiliza para ingresar un registro dentro de la tabla. tabla contiene el nombre de la tabla MySQL a la cual le queremos ingresar la información. El nombre de la tabla puede ser seguido por la lista de columnas a las cuales se les insertarán los datos y VALUES() contiene los valores que deseas insertar en la tabla. Puedes omitir la lista de columnas si insertas un valor en cada una y si los pones en el mismo orden en el cual las columnas han sido definidas. En este caso, queremos insertar información dentro de la tabla developers. Insertemos algunos registros de ejemplo:

mysql> INSERT INTO developers VALUES('Joe Smith', 'joesmith@gentoo.org', 'toolchain');
Query OK, 1 row affected (0.06 sec)
(Si no conoces el orden de las columnas o si deseas ingresar un registro incompleto)
mysql> INSERT INTO developers (job, name) VALUES('outsourced', 'Jane Doe');
Query OK, 1 row affected (0.01 sec)

De acuerdo con el resultado, parece que el registro ha sido insertado correctamente. ¿Qué sucede si deseamos ingresar más de un solo registro?. Ahí es donde el comando LOAD DATA entra en acción. Este carga los registros desde un archivo separado. Probémoslo con un archivo en nuestro directorio raíz que contenga registros. Llamaremos a este archivo records.txt. Veamos un ejemplo:

John Doe  johndoe@gentoo.org  portage
Chris White  chriswhite@gentoo.org  documentation
Sam Smith  samsmith@gentoo.org  amd64

Ahora, el comando LOAD DATA tiene una ligeramente larga definición, pero utilizaremos su forma más simple.

LOAD DATA LOCAL INFILE '/ruta/al/archivo' INTO TABLE tabla;

/ruta/al/archivo es el directorio y nombre del archivo que se utilizará. tabla es el nombre de nuestra tabla. En este caso el archivo es ~/records.txt y la tabla es developers.

mysql> LOAD DATA LOCAL INFILE '~/records.txt' INTO TABLE developers;
Query OK, 3 rows affected (0.00 sec)
Records: 3  Deleted: 0  Skipped: 0  Warnings: 0

Eso funcionó bien. Sin embargo, esto simplemente inserta registros, no te da ningún tipo de control sobre MySQL. Muchas aplicaciones web utilizan guiones sql para poder configurar rápida y fácilmente MySQL. Si quieres utilizar un guión sql, tendrás que ejecutar mysql en modo por lotes, o cargando un archivo fuente. Aquí hay un ejemplo de mysql en modo por lotes:

$ mysql -u root -h localhost -p < sqlfile

Al igual que en LOAD DATA debes estar seguro de lo que dice el archivo sqlfile. Si fallas en asegurarte de ello tu base de datos puede ser comprometida Otra forma en la que puedes lograrlo es utilizando el comando source. Este comando ejecutará los comandos mysql desde un archivo sql mientras se está en el modo interactivo. Aquí tenemos un ejemplo:

mysql> source sqlfile;

Si ves alguna aplicación web que te pide ejecutar un archivo sql, los dos comandos anteriores pueden ser utilizados para completar esta tarea. Tenemos nuestra tabla configurada, entonces ¿cómo vemos nuestros campos? Esto lo hacemos buscando en nuestra tabla utilizando consultas.

Explorando las tablas MySQL mediante consultas

Las consultas son una de las más importantes características de cualquier base de datos SQL. Nos ayudan a convertir los datos de nuestras tablas en información útil. La mayoría de las consultas se hacen a través del comando SELECT. El comando SELECT es muy complejo, pero nosotros vamos a trabajar en este documento con tres formas principales.

(Seleccionar todas las entradas de una tabla)
SELECT * FROM tabla;
(Seleccionar una entrada específica en una tabla)
SELECT * FROM tabla WHERE campo=valor;
(Seleccionar campos específicos)
SELECT campo1,campo2,campo3 FROM tabla [WHERE campo=valor];

Démosle una rápida mirada a la primera forma. Es relativamente simple y te da una mirada general de tu tabla. Bueno, sigamos adelante y revisemos que datos tenemos hasta ahora.

mysql> SELECT * FROM developers;
+-------------+-----------------------+----------------+
| name        | email                 | job            |
+-------------+-----------------------+----------------+
| Joe Smith   | joesmith@gentoo.org   | toolchain      |
| John Doe    | johndoe@gentoo.org    | portage        |
| Chris White | chriswhite@gentoo.org | documentation  |
| Sam Smith   | samsmith@gentoo.org   | amd64          |
| Jane Doe    | NULL                  | Outsourced job |
+-------------+-----------------------+----------------+
5 rows in set (0.00 sec)

Podemos ver los datos que ingresamos mediante INSERT y los que insertamos utilizando LOAD DATA. Ahora, digamos que solo queremos ver el registro de Chris White. Podemos hacerlo con la segunda forma tal y como se muestra a continuación.

mysql> SELECT * FROM developers WHERE name = 'Chris White';
+-------------+-----------------------+---------------+
| name        | email                 | job           |
+-------------+-----------------------+---------------+
| Chris White | chriswhite@gentoo.org | documentation |
+-------------+-----------------------+---------------+
1 row in set (0.08 sec)

Como esperábamos, la entrada específica que estábamos buscando ha sido seleccionada. Ahora, digamos que solo queremos saber el trabajo y dirección de correo electrónico de la persona pero no su nombre. Eso lo conseguimos con la tercera forma de SELECT como vemos a continuación.

mysql> SELECT email,job FROM developers WHERE name = 'Chris White';
+-----------------------+---------------+
| email                 | job           |
+-----------------------+---------------+
| chriswhite@gentoo.org | documentation |
+-----------------------+---------------+
1 row in set (0.04 sec)

Este método de selección es mucho más fácil de manejar, especialmente con cantidades mayores de información, como veremos más adelante. Ahora, estando conectado a la base de datos como el super usuario, tenemos permisos ilimitados para hacer cualquier cosa en la base de datos MySQL. En un ambiente de servidor, un usuario con tales privilegios puede ser muy problemático. Para poder controlar quién puede hacer qué en la base de datos, definimos privilegios.

4.  Privilegios en MySQL

Definiendo privilegios con GRANT

Los privilegios son qué tipo de acceso tienen los usuarios a las bases de datos, tablas y esencialmente a todo. En este preciso momento en la base de datos gentoo, la cuenta de super usuario MySQL es la única que puede acceder a ella, dados sus permisos. Ahora, creemos dos usuarios bastante genéricos, guest y admin, quienes accederán a la base de datos gentoo y trabajarán con la información en ella. La cuenta guest será restringida. Todo lo que será capaz de hacer es realizar consultas para obtener información de la base de datos, y eso es todo. admin tendrá el mismo control que el super usuario pero solo para la base de datos gentoo (no la base de datos mysql principal). Antes de que empecemos, veamos una forma bastante simplificada del comando GRANT.

GRANT [privilegios] ON database.* TO '[user]'@'[host]' IDENTIFIED BY '[password]';

Primero tenemos los privilegios que deseamos asignar. Con lo que hemos aprendido hasta ahora, aquí están algunos de los privilegios que puedes asignar:

• ALL - Da el privilegio de control total para la base de datos
• CREATE - Permite a los usuarios crear tablas
• SELECT - Permite a los usuarios realizar consultas
• INSERT - Permite a los usuarios insertar datos en una tabla
• SHOW DATABASES - Permite a los usuarios listar las bases de datos
• USAGE - El usuario no tiene privilegios
• GRANT OPTION - Permite a los usuarios dar privilegios

Para nuestro usuario admin, utilizaremos ALL. Para el usuario guest, SELECT será suficiente para un acceso de solo lectura. database es la base de datos en la cual deseamos el usuario tenga los permisos. En este ejemplo, gentoo es nuestra base de datos. El .* representa a todas las tablas. Si deseas, puedes modificar el acceso por tabla. user es el nombre del usuario y host es el nombre de la máquina desde la cual el usuario accederá. En la mayoría de los casos, esta será localhost. Finalmente, password es la contraseña del usuario. Dada esta información, crearemos nuestros usuarios.

(admin)
mysql> GRANT ALL ON gentoo.* TO 'admin'@'localhost' IDENTIFIED BY 'password';
(guest)
mysql> GRANT SELECT ON gentoo.* TO 'guest'@'localhost' IDENTIFIED BY 'password';

Ahora que hemos definido los usuarios, probémoslos. Primero salimos de mysql ejecutando el comando quit en el cursor:

mysql> quit

Ahora hemos regresado a la consola. Dado que ya tenemos configurados los usuarios, continuemos y veamos que pueden hacer.

Probando los permisos de los usuarios

Ahora debemos intentar ingresar con nuestro usuario guest. Actualmente, el usuario guest solamente tiene los privilegios SELECT. Esto básicamente significa que es capaz de buscar y nada más. Ingresemos con la cuenta guest.

$ mysql -u guest -h localhost -p
Enter password:
Welcome to the MySQL monitor. Commands end with ; or \g.
Your MySQL connection id is 6 to server version: 4.0.25

Type 'help;' or '\h' for help. Type '\c' to clear the buffer.

mysql>

Ahora debemos probar las restricción(es) del usuario. Entremos a la base de datos gentoo:

mysql> USE gentoo;
Reading table information for completion of table and column names
You can turn off this feature to get a quicker startup with -A

Database changed

Ahora intentemos hacer algo que se supone no debemos hacer. Intentaremos crear una tabla

mysql> CREATE TABLE test (test VARCHAR(20), foobar VARCHAR(2));
ERROR 1044: Access denied for user: 'guest@localhost' to database 'gentoo'

Como puedes ver, esta función falló, dado que nuestro usuario no tiene los accesos necesarios. Sin embargo, un acceso que sí posee es el de SELECT. Probémoslo:

mysql> SELECT * FROM developers;
+-------------+-----------------------+----------------+
| name        | email                 | job            |
+-------------+-----------------------+----------------+
| Joe Smith   | joesmith@gentoo.org   | toolchain      |
| John Doe    | johndoe@gentoo.org    | portage        |
| Chris White | chriswhite@gentoo.org | documentation  |
| Sam Smith   | samsmith@gentoo.org   | amd64          |
| Jane Doe    | NULL                  | Outsourced job |
+-------------+-----------------------+----------------+
5 rows in set (0.00 sec)

El comando tuvo éxito, y con ello tenemos una vista parcial de lo que se puede hacer con los permisos de los usuarios. Nosotros también, sin embargo, hemos creado una cuenta admin. Esta se creó con la intención de mostrar que incluso los usuarios con todos los permisos pueden tener limitaciones. Probemos esta cuenta ingresando como admin.

mysql> quit
Bye
$ mysql -u admin -h localhost -p
Enter password:
Welcome to the MySQL monitor. Commands end with ; or \g.
Your MySQL connection id is 7 to server version: 4.0.25

Type 'help;' or '\h' for help. Type '\c' to clear the buffer.

mysql>

Para comenzar, intentaremos crear una nueva base de datos con nuestro usuario admin. Este usuario admin tendrá accesos similares a la cuenta super usuario de MySQL, y será capaz de realizar cualquier tipo de modificación que desee sobre la base de datos gentoo. A continuación probaremos el acceso del usuario a la base de datos principal de MySQL. Recuerda que anteriormente solo definimos permisos para una base de datos específica.

mysql> CREATE DATABASE gentoo2;
ERROR 1044: Access denied for user: 'admin@localhost' to database 'gentoo2'

En efecto, el usuario admin no puede crear bases de datos en la base de datos MySQL principal, sin importar todos los permisos que tiene en la base de datos gentoo. Sin embargo, nosotros seguimos siendo capaces de modificar la base de datos gentoo a través de la cuenta admin, como se muestra en el siguiente ejemplo de inserción.

mysql> USE gentoo;
Reading table information for completion of table and column names
You can turn off this feature to get a quicker startup with -A

Database changed
mysql> INSERT INTO developers VALUES('Bob Simmons', 'bobsimmons@gentoo.org', 'python');
Query OK, 1 row affected (0.08 sec)

El usuario admin puede acceder a la base de datos como desee. Algunas veces se necesita retirar algunos permisos de los usuarios. Esto puede suceder debido a casos que van desde un usuario problemático hasta un empleado retirado. Veamos como desactivar permisos de usuarios con el comando REVOKE.

Retirando permisos de usuarios con el comando REVOKE

El comando REVOKE nos permite denegar accesos a los usuarios. Se puede negar completamente el acceso, o alguno específico. De hecho, su formato es muy similar a GRANT.

REVOKE [privileges] ON database.* FROM '[user]'@'[host]';

Las opciones de aquí están explicadas en la sección del comando GRANT. En esta sección sin embargo, vamos a denegar completamente el acceso a un usuario. Digamos que hemos encontrado que la cuenta guest está causando algunos problemas de seguridad. Hemos decidido revocarle todos los permisos, así que ingresamos como super usuario y hacemos lo necesario.

mysql> REVOKE ALL ON gentoo.* FROM 'guest'@'localhost';
Query OK, 0 rows affected (0.00 sec)

Ahora salgamos he intentemos ingresar como el usuario guest.

$ mysql -u guest -h localhost -p
Enter password:
Welcome to the MySQL monitor. Commands end with ; or \g.
Your MySQL connection id is 9 to server version: 4.0.24-debug

Type 'help;' or '\h' for help. Type '\c' to clear the buffer.

mysql>

Aunque hemos sido capaces de ingresar, nuestro acceso a gentoo ya no existe.

mysql> USE gentoo;
ERROR 1044: Access denied for user: 'guest@localhost' to database 'gentoo'

Y con esto nuestro usuario problemático ya no es capaz de acceder a la base de datos gentoo. Por favor fíjate que el usuario todavía es capaz de ingresar al sistema. Esto es porque todavía está registrado en la base de datos principal de MySQL. Veamos como eliminar completamente una cuenta con DELETE y la tabla de usuarios de MySQL.

Eliminando cuentas con DELETE

La tabla de usuarios de MySQL contiene a todos los usuarios e información sobre ellos. Asegúrate de ingresar como super usuario, luego utiliza la base de datos principal de MySQL.

mysql> USE mysql;
Reading table information for completion of table and column names
You can turn off this feature to get a quicker startup with -A

Database changed
mysql>

Ahora veamos qué tablas contiene la base de datos mysql:

mysql> SHOW TABLES;
+-----------------+
| Tables_in_mysql |
+-----------------+
| columns_priv    |
| db              |
| func            |
| host            |
| tables_priv     |
| user            |
+-----------------+
6 rows in set (0.00 sec)

La tabla user es la que estamos buscando. Sin embargo, la tabla usuario contiene 30 campos distintos, haciéndola muy difícil de leer. Para poder hacer las cosas más simples, vamos a utilizar la tercera versión del comando SELECT. Los campos que necesitamos son Host y User.

mysql> SELECT Host,User FROM user WHERE User = 'guest';
+-----------+-------+
| Host      | User  |
+-----------+-------+
| localhost | guest |
+-----------+-------+
1 row in set (0.00 sec)

Ahora que tenemos nuestra información, podemos deshacernos de nuestra cuenta guest. Esto lo conseguimos con el comando DELETE y la sintaxis que mostramos a continuación.

DELETE FROM table WHERE field='value';

Como podrás ver, DELETE es algo similar al comando SELECT en cuanto al formato. En este caso, el field (campo) será User, y el valor será guest. Esto eliminará el registro del usuario guest de la tabla user, con lo que lograremos eliminar exitosamente la cuenta de usuario guest. Ahora, hagámoslo:

mysql> DELETE FROM user WHERE User='guest';
Query OK, 1 row affected (0.07 sec)
(se necesita FLUSH PRIVILEGES para actualizar los permisos del usuario)
mysql> FLUSH PRIVILEGES;
Query OK, 0 rows affected (0.00 sec)

Parece haber funcionado sin problemas. Probémoslo saliendo y tratando de ingresar de nuevo con nuestra cuenta de usuario guest.

mysql> quit
Bye
$ mysql -u guest -h localhost -p
Enter password:
ERROR 1045: Access denied for user: 'guest@localhost' (Using password: YES)

¡Nuestro usuario ha sido exitosamente eliminado!

Conclusión

Mientras esta guía se centra principalmente en configurar MySQL en la línea de comandos, existes algunas alternativas con la forma GUI:

• phpMyAdmin - Popular herramienta administrativa de Mysql basada en php
• mysqlnavigator - Interfaz en QT de MySQL.
• gmyclient - Un cliente MySQL basado en GNOME.
• knoda - Un cliente MySQL KDE.

Esto da por concluido el tutorial introductorio de MySQL. Espero que te haya dado un mejor entendimiento de los aspectos básicos detrás de MySQL y como levantar una base de datos. Por favor, envíame un correo electrónico a Chris White si tienes algún comentario.

El contenido de este documento, a no ser que se especifique expresamente, está registrado bajo los términos de la licencia CC-BY-SA-2.5. Se aplican las Pautas de Utilización del logotipo y nombre de Gentoo.