Comandos de Mysql

Hoy vamos a hablar acerca de los comandos mas usados en MySQL, su sintaxis y daremos algunos ejemplos.

Comenzaremos con el comando SHOW el cual nos permite ver cuales son las tablas, bases de datos, permisos, motores de almacenamiento, entre otros disponibles en nuestro servidor MySQL.

Después de acceder de manera normal en su servidor Mysql, si desea saber que bases de datos hay disponibles debe usar el comando SHOW DATABASES como se muestra a continuación:

mysql> SHOW DATABASES;
+--------------------+
| Database           |
+--------------------+
| information_schema |
| mysql              |
| performance_schema |
| zerocool           |
+--------------------+
4 rows in set (0.00 sec)

Para poder utilizar alguna de esas bases de datos que se nos presentan necesitamos el comando USE Nombre_de_base_de_datos. En el ejemplo siguiente mostraré como  trabajar con la base de datos MySQL:

mysql> USE mysql;
Database changed

Una vez en la base de datos podemos ver que tablas contiene usando SHOW TABLES:

mysql> SHOW TABLES;
+---------------------------+
| Tables_in_mysql           |
+---------------------------+
| columns_priv              |
| db                        |
| event                     |
| func                      |
| general_log               |
| help_category             |
| help_keyword              |
| help_relation             |
| help_topic                |
| host                      |
| ndb_binlog_index          |
| plugin                    |
| proc                      |
| procs_priv                |
| proxies_priv              |
| servers                   |
| slow_log                  |
| tables_priv               |
| time_zone                 |
| time_zone_leap_second     |
| time_zone_name            |
| time_zone_transition      |
| time_zone_transition_type |
| user                      |
+---------------------------+
24 rows in set (0.00 sec)

Si queremos ver las columnas dentro de una tabla usaríamos SHOW COLUMNS FROM nombre_tabla:

mysql>SHOW COLUMNS FROM db;
+-----------------------+---------------+------+-----+---------+-------+
| Field                 | Type          | Null | Key | Default | Extra |
+-----------------------+---------------+------+-----+---------+-------+
| Host                  | char(60)      | NO   | PRI |         |       |
| Db                    | char(64)      | NO   | PRI |         |       |
| User                  | char(16)      | NO   | PRI |         |       |
| Select_priv           | enum('N','Y') | NO   |     | N       |       |
| Insert_priv           | enum('N','Y') | NO   |     | N       |       |
| Update_priv           | enum('N','Y') | NO   |     | N       |       |
| Delete_priv           | enum('N','Y') | NO   |     | N       |       |
| Create_priv           | enum('N','Y') | NO   |     | N       |       |
| Drop_priv             | enum('N','Y') | NO   |     | N       |       |
| Grant_priv            | enum('N','Y') | NO   |     | N       |       |
| References_priv       | enum('N','Y') | NO   |     | N       |       |
| Index_priv            | enum('N','Y') | NO   |     | N       |       |
| Alter_priv            | enum('N','Y') | NO   |     | N       |       |
| Create_tmp_table_priv | enum('N','Y') | NO   |     | N       |       |
| Lock_tables_priv      | enum('N','Y') | NO   |     | N       |       |
| Create_view_priv      | enum('N','Y') | NO   |     | N       |       |
| Show_view_priv        | enum('N','Y') | NO   |     | N       |       |
| Create_routine_priv   | enum('N','Y') | NO   |     | N       |       |
| Alter_routine_priv    | enum('N','Y') | NO   |     | N       |       |
| Execute_priv          | enum('N','Y') | NO   |     | N       |       |
| Event_priv            | enum('N','Y') | NO   |     | N       |       |
| Trigger_priv          | enum('N','Y') | NO   |     | N       |       |
+-----------------------+---------------+------+-----+---------+-------+
22 rows in set (0.00 sec)

Hay muchas mas cosas que se pueden ver con el comando SHOW como las alertas, errores, entre otros. Si desea revisar mas a fondo el comando puede revisar el siguiente enlace: http://dev.mysql.com/doc/refman/5.0/es/show.html.

Ahora veremos como usar el comando CREATE. Con CREATE podemos crear usuarios, bases de datos, tablas, entre otros. Para crear usuarios usaremos el comando de la siguiente forma:

mysql> CREATE USER 'nombre_usuario'@'nombre_host_o_ip'\ 
       IDENTIFIED BY mi_password';

En el ejemplo se creó un usuario llamado nombre_usuario, el cual, tiene permiso de acceder al servidor MySQL que posee la dirección nombre_host_o_ip y posee el password mi_password. Por ejemplo para crear el usuario aang, que accede en localhost y posee el password appa se usa el siguiente comando:

mysql> CREATE USER 'aang'@'localhost' IDENTIFIED BY 'appa';

Para crear bases de datos se debe usar CREATE DATABASE de la manera siguiente:

mysql> CREATE DATABASE Prueba;

Como se puede apreciar se creó una base de datos de nombre Prueba. El nombre de las bases de datos deben seguir las reglas estipuladas para nombres de bases de datos, tablas, indices, columnas y alias, las cuales puede encontrar en el siguiente enlace: http://dev.mysql.com/doc/refman/5.0/es/legal-names.html.

Si desea crear tablas se debe usar CREATE TABLE, la sintaxis de este comando es un poco mas compleja debido a que aquí se debe especificar todas las características de la tabla, si comete un error pequeño no se preocupe porque luego con el comando ALTER podrá modificar la estructura de la misma. A continuación se presenta la sintaxis:

mysql> CREATE TABLE Nombre_tabla (columna_1 tipo_de_dato(tamaño)\
       default (dato_inicial) opciones,..., columna_n tipo_de_dato(tamaño)\
       default (dato_inicial) opciones PRIMARY KEY (columna_x));

En donde tipo de dato puede ser numérico, caracteres o de tipo fecha.

Entre los numéricos encontramos los enteros (INT permite números enteros que van desde -2147483648 hasta 2147483648), punto flotante (FLOAT tiene una precisión decimal por defecto de hasta 4 bytes), de doble precisión (DOUBLE tiene una precisión decimal por defecto de hasta 8 bytes) y para almacenar bits (BIT con valores que van de 0 a 1 :)). Una descripción completa de los tipos de datos numéricos se encuentra en el siguiente enlace: http://dev.mysql.com/doc/refman/5.0/es/numeric-types.html.

Los de tipo carácter mas usados son: cadenas de caracteres de longitud fija (CHAR), cadenas de longitud variable (VARCHAR permite almacenar de 0 a 65.535 caracteres), cadenas para almacenar números binarios (BINARY/VARBINARY), para almacenar textos grandes de longitud variable (TEXT), almacenar textos grandes de longitud variable en formato binario (BLOB). Para mas información revisar http://dev.mysql.com/doc/refman/5.0/es/string-types.html.

En cuanto a los tipos de datos de fecha tenemos DATETIME para almacenar fecha y hora en formato 'AAAA-MM-DD HH:MM:SS' (ejm. 2012-08-10 00:35:25), DATE en formato 'AAAA-MM-DD', entre otros. Detalles sobre esto en: http://dev.mysql.com/doc/refman/5.0/es/date-and-time-types.html.

Debemos tener presente en cual base de datos crearemos la tabla, si la tabla a crear pertenece a la base de datos Prueba debemos usar el comando USE Prueba; para ubicarnos dentro de la base de datos a la que pertenecen las tablas.

Después de especificar los nombres y tipos de datos que maneja cada tabla debemos especificar cual es la clave primaria (primary key) de existir y ser necesaria. Si desempolvamos los libros de fundamentos de bases de datos recordaremos que una clave primaria es un campo de una tabla que identifica de manera única una fila. Un ejemplo de esto es una tabla que posee datos de personas, si pensamos un poco el atributo de una persona que la puede hacer única (aparte del ADN y sus huellas digitales) es su número de cédula (conocido en otros países como carta de identificación, numero de seguro social), por esta razón este campo debería especificarse como la clave primaria de una tabla.

También existe un tipo de clave importante llamado clave foránea (foreign key) y sirve para relacionar tablas. Si tenemos una tabla proveedor que posee un id_proveedor (clave primaria), nombre, dirección y tenemos otra tabla llamada producto con id_producto (clave primaria), nombre, descripción podríamos relacionar los productos con los proveedores que los venden mediante una clave foránea (id_proveedor) en la tabla producto. Ejemplo:

mysql> USE Prueba;
mysql> CREATE TABLE proveedor (id_proveedor INT (6) NOT NULL PRIMARY KEY,\
       nombre CHAR (20) default NULL, dirección TEXT);
mysql> CREATE TABLE producto (id_producto INT (6) NOT NULL PRIMARY KEY, \
       id_proveedor INT(6) NOT NULL, nombre CHAR (20) default NULL,\
       descripcion CHAR(40), constraint fk_id_proveedor FOREIGN KEY\
       (id_proveedor) REFERENCES proveedor (id_proveedor));

Nota: También podemos referirnos a una tabla dentro de una base de datos mediante Nombre_base_de_datos.Nombre_de_tabla. Usando este formato el comando quedaría como CREATE TABLE Prueba.proveedor (...).
Nota 2: si deseamos que los identificadores de proveedor y de producto aumenten de uno en uno sin necesidad de colocarlo nosotros mismos basta con agregar la palabra clave autoincrement. Ejemplo: CREATE TABLE proveedor (id_proveedor INT (6) NOT NULL PRIMARY KEY autoincrement, ...);
Bien una vez creada nuestra base de datos y dos tablas de prueba vamos a insertar valores. Esto se hace mediante el comando INSERT. Antes de llenar con valores las tablas es necesario saber la estructura de las mismas, si no lo recordamos podemos usar el comando DESCRIBE de la manera siguiente: DESCRIBE Nombre_de_tabla. Ejemplo:

mysql> DESCRIBE proveedor;
+--------------+----------+------+-----+---------+-------+
| Field        | Type     | Null | Key | Default | Extra |
+--------------+----------+------+-----+---------+-------+
| id_proveedor | int(6)   | NO   | PRI | NULL    |       |
| nombre       | char(20) | YES  |     | NULL    |       |
| dirección    | text     | YES  |     | NULL    |       |
+--------------+----------+------+-----+---------+-------+

Ahora que recordamos la estructura usaremos INSERT de la siguiente forma: INSERT INTO Nombre_tabla VALUES(val1,val2,...,valn);. Ejemplo:

mysql> INSERT INTO proveedor VALUES(1,'Palmolive','Calle los dos rios,\
       Desierto del Sahara');
Query OK, 1 row affected (0.04 sec)

Para agregar múltiples valores con un solo comando hacemos lo siguiente:

INSERT INTO proveedor VALUES(2,'Goodyear','Calle seca, Mar Caribe'),\
       (3, 'Distribuidora azul', 'Av. la piscina, sector sin agua'),\
       (4,'Badyear','Sin dirección');
Query OK, 3 rows affected (0.03 sec)
Records: 3  Duplicates: 0  Warnings: 0

Ahora vamos a cargar algunos datos en nuestra tabla productos pero especificando el nombre de cada columna en la cual se va a insertar información:

mysql> INSERT INTO producto(id_producto,id_proveedor,nombre,descripcion)\
       VALUES(1,1,'jabón azul','jabón para lavar'),(2,2,'Caucho radial',\
       'Caucho antiresbalante'),(3,1,'Champú','Champú anticaspa'),\
       (4,4,'Caucho liso','Caucho resbalante');
Query OK, 4 rows affected (0.03 sec)
Records: 4  Duplicates: 0  Warnings: 0

El segundo método es recomendable debido a que nos permite tener una guía de que valor va en que columna de la tabla.

Ahora necesitamos ver que valores tenemos almacenados en nuestra tabla, esto se logra mediante el comando SELECT. La forma mas sencilla de usar SELECT es con el operador * que significa todo, así, que si queremos traer todos los campos de una tabla llamada nombre_tabla colocaríamos SELECT * FROM Nombre_tabla. Ejemplo:

mysql> SELECT * FROM producto;
+-------------+--------------+---------------+------------------------+
| id_producto | id_proveedor | nombre        | descripción            |
+-------------+--------------+---------------+------------------------+
|           1 |            1 | jabón azul    | jabón para lavar       |
|           2 |            2 | Caucho radial | Caucho  antiresbalante |
|           3 |            1 | Champú        | Champú anticaspa       |
|           4 |            4 | Caucho liso   | Caucho resbalante      |
+-------------+--------------+---------------+------------------------+
4 rows in set (0.00 sec)

Para crear preguntas mas complejas podemos escoger que campo necesitamos de una tabla y, mediante la palabra clave WHERE (donde) especificar que valor debe tener una entrada para que nos devuelva un resultado. Supongamos que deseamos saber que descripción tiene el producto llamado caucho liso:

mysql> SELECT descripcion FROM producto WHERE nombre='Caucho liso';
+-----------------------+
| descripcion           |
+-----------------------+
| Caucho resbalante     |
+-----------------------+
1 row in set (0.00 sec)

Ahora que tenemos una idea de como se buscan valores en una base de datos juguemos con el enlace entre las tablas que creamos. Si quiero saber el nombre del proveedor del producto Champú y su dirección debo hacer una pregunta compuesta. Ya sabemos que si preguntamos en la tabla producto por el id_proveedor de Champú obtendremos su identificador y luego buscamos en la tabla proveedor cual es el nombre y la dirección del proveedor. Para hacer estas dos operaciones en una sola pregunta haríamos lo siguiente:

mysql> SELECT nombre,dirección FROM proveedor WHERE id_proveedor=\
       (SELECT id_proveedor FROM producto WHERE nombre='Champú');
+-----------+-----------------------------------------+
| nombre    | dirección                               |
+-----------+-----------------------------------------+
| Palmolive | Calle los dos rios, Desierto del Sahara |
+-----------+-----------------------------------------+
1 row in set (0.00 sec)

Demas esta decirles que pueden combinar los SELECT con los INSERT y casi cualquier comando de MySQL.

Si necesitamos ordenar los resultados de alguna pregunta con SELECT basta usar ORDER BY. Si requerimos que se nos muestre el identificador de los proveedores con sus respectivos  nombres y que se muestren en orden alfabético basta con colocar al final ORDER BY nombre. Ejemplo:

mysql> SELECT id_proveedor,nombre FROM proveedor ORDER BY nombre;
+--------------+----------------+
| id_proveedor | nombre         |
+--------------+----------------+
|            3 | Av. la piscina |
|            4 | Badyear        |
|            2 | Goodyear       |
|            1 | Palmolive      |
+--------------+----------------+
4 rows in set (0.00 sec)

Luego de un tiempo creando tablas e insertando valores en las tablas nos vamos a ver en la necesidad de borrar entradas, para esto debemos usar el comando DELETE, el cual, posee la siguiente sintaxis: DELETE FROM Nombre_tabla WHERE condición. Ejemplo:
Supongamos que introduje un producto llamado hizopopos en vez de hisopos y deseo borrarlo:

mysql> SELECT * FROM producto;
+-------------+--------------+---------------+----------------------------+
| id_producto | id_proveedor | nombre        | descripcion                |
+-------------+--------------+---------------+----------------------------+
|           1 |            1 | jabón azul    | jabón para lavar           |
|           2 |            2 | Caucho radial | Caucho  que no resbala     |
|           3 |            1 | Champú        | Champú anticaspa           |
|           4 |            4 | Caucho liso   | Caucho que si resbala      |
|           5 |            1 | hizopopos     | hisopos para limpiar oidos |
+-------------+--------------+---------------+----------------------------+
5 rows in set (0.00 sec)

Podriamos tener un par de enfoques para atacar este problema, como sabemos cual es el id_producto podriamos borrarlo con DELETE FROM producto WHERE id_producto=5;, otra forma sería borrarlo por nombre con DELETE FROM producto WHERE nombre='hizopopos'; es recomendable usar el primero en este caso debido a que el id_producto identifica de manera única a una entrada en la tabla así que será el comando que usaremos:

mysql> DELETE FROM producto WHERE id_producto=5;
Query OK, 1 row affected (0.02 sec)

Mucho cuidado con el comando DELETE ya que sin no le pasan ningún argumento borrará todas las entradas de la tabla. Veamos un Ejemplo:

mysql> DELETE FROM producto;
Query OK, 4 rows affected (0.02 sec)
mysql> SELECT * FROM producto;
Empty set (0.00 sec)

Considérense advertidos :).

Pueden usar también las palabras reservadas AND(operador lógico i) y OR (operador lógico o) para realizar selecciones, eliminar entradas, entre otros. Imagínense que por unas razón obscura requieren buscar quienes proveen cauchos que resbalen o que no resbalen en las tablas de ejemplo:

mysql> SELECT nombre FROM proveedor WHERE id_proveedor=\
       (SELECT id_proveedor FROM producto WHERE descripcion\
        ='Caucho antiresbalante' OR descripcion='Caucho resbalante'); 
ERROR 1242 (21000): Subquery returns more than 1 row

Como pueden apreciar en este caso MySQL nos insulta con un error 1242 (la subpregunta retorna mas de una columna) esto ocurre porque para preguntas compuestas que devuelvan múltiples respuestas se debe usar IN:

mysql> SELECT nombre FROM proveedor WHERE id_proveedor IN\
       (SELECT id_proveedor FROM producto WHERE descripcion=\
       'Caucho antiresbalante' OR descripcion='Caucho resbalante');
+----------+
| nombre   |
+----------+
| Goodyear |
| Badyear  |
+----------+
2 rows in set (0.00 sec)

Ahora vamos a ver un ejemplo con el operador lógico i, supongamos que deseo saber el identificador de producto del objeto que tiene en su nombre la palabra jabón y es distribuido por el proveedor Palmolive el cuál tiene el id_proveedor de 1. Lo mas probable es que usted piense eso es fácil coloco el siguiente query SELECT id_producto FROM producto WHERE nombre='jabón' AND id_proveedor=1;, y esto le retornará un resultado  vacio debido a que el operador '=' es literal, osea, el resultado debe ser exactamente igual a lo que se solicita. En este caso entra el operador LIKE al rescate, con el operador LIKE y los símbolos % (que significan cualquier cosa) podemos crear preguntas del tipo necesito que me traigas los objetos que contienen cualquier cosa al principio luego jabón y cualquier cosa al final:

mysql> SELECT id_producto FROM producto WHERE nombre LIKE '%jabón%'\
       AND id_proveedor=1;
+-------------+
| id_producto |
+-------------+
|           1 |
+-------------+
1 row in set (0.00 sec)

En este caso hubiera bastado con colocar jabón% pero coloqué los dos en caso de que quieran buscar también resultados como "El jabón verde" por ejemplo.
Es fácil abusar del operador LIKE y terminar con mas resultados de los que necesitamos así que úsenlo con cautela.

Ahora necesitamos cambiar los valores que posee una determinada entrada dentro de una tabla. Para esto usamos los comandos UPDATE y SET. La sintaxis de UPDATE es: UPDATE nombre_tabla SET nombre_columna=nuevo_valor WHERE nombre_columna=viejo_valor. Imaginémonos que en el ejemplo anterior tengamos un nuevo proveedor llamado procter and gamble y vende mas barato el jabón azul así que queremos que el nuevo proveedor de este producto sea procter. Debemos tener cuidado en este tipo de operaciones debido a que estas tablas se encuentran enlazadas. Primero vamos a crear el nuevo proveedor y luego vamos a cambiar el id_del proveedor del jabón azul de Palmolive a procter and gamble, finalmente mostraré los datos del nuevo proveedor de jabón azul con una subpregunta:

mysql> INSERT INTO proveedor VALUES(5,'Procter and Gamble','En su casa');
Query OK, 1 row affected (0.02 sec)
mysql> UPDATE producto SET id_proveedor=5 WHERE nombre='jabón azul';
Query OK, 1 row affected (0.04 sec)
Rows matched: 1  Changed: 1  Warnings: 0
mysql> SELECT * FROM proveedor WHERE id_proveedor=\
       (SELECT id_proveedor FROM producto WHERE nombre='jabón azul');
+--------------+--------------------+------------+
| id_proveedor | nombre             | dirección  |
+--------------+--------------------+------------+
|            5 | Procter and Gamble | En su casa |
+--------------+--------------------+------------+
1 row in set (0.00 sec)

Nótese que también pude haber cambiado el valor del proveedor del jabón azul por su id_producto en vez de por su nombre.
Si deseamos cambiar la estructura de una tabla debemos usar el comando ALTER. Con este podemos agregar campos, quitar campos, cambiar opciones de las columnas (siempre y cuando no alteren los enlaces que puedan tener con otras tablas), entre otros.
La sintaxis de este comando es la siguiente: ALTER TABLE nombre_tabla [ADD|DROP|MODIFY|RENAME] nombre_columna opciones. Comencemos agregando una columna a la tabla productos que se llame disp, esta tendrá la cantidad que se tiene de un producto y solo puede ser positiva o cero (no creo que podamos almacenar -5000 cauchos ;)), ademas su valor por defecto será cero:

mysql> ALTER TABLE producto ADD disp INT UNSIGNED default 0;
Query OK, 4 rows affected (0.08 sec)
Records: 4  Duplicates: 0  Warnings: 0
mysql> select * FROM producto;
+-------------+--------------+---------------+-----------------------+------+
| id_producto | id_proveedor | nombre        | descripcion           | disp |
+-------------+--------------+---------------+-----------------------+------+
|           1 |            5 | jabón azul    | jabón para lavar      |    0 |
|           2 |            2 | Caucho radial | Caucho antiresbalante |    0 |
|           3 |            1 | Champú        | Champú anticaspa      |    0 |
|           4 |            4 | Caucho liso   | Caucho resbalante     |    0 |
+-------------+--------------+---------------+-----------------------+------+
4 rows in set (0.00 sec)

Ahora cambiamos los valores de la disponibilidad con UPDATE:

mysql> UPDATE producto SET disp=150 WHERE id_producto=1;
Query OK, 1 row affected (0.03 sec)
Rows matched: 1  Changed: 1  Warnings: 0
mysql> UPDATE producto SET disp=250 WHERE id_producto=2;
Query OK, 1 row affected (0.02 sec)
Rows matched: 1  Changed: 1  Warnings: 0
mysql> UPDATE producto SET disp=589 WHERE id_producto=4;
Query OK, 1 row affected (0.02 sec)
Rows matched: 1  Changed: 1  Warnings: 0
mysql> SELECT * FROM producto;
+-------------+--------------+---------------+-----------------------+------+
| id_producto | id_proveedor | nombre        | descripcion           | disp |
+-------------+--------------+---------------+-----------------------+------+
|           1 |            5 | jabón azul    | jabón para lavar      |  150 |
|           2 |            2 | Caucho radial | Caucho antiresbalante |  250 |
|           3 |            1 | Champú        | Champú anticaspa      |    0 |
|           4 |            4 | Caucho liso   | Caucho resbalante     |  589 |
+-------------+--------------+---------------+-----------------------+------+
4 rows in set (0.00 sec)

Ahora supongamos que tienen un blog en blogger y notan que las tablas Mysql son muy anchas para caber en el frame central, luego notan que los nombres id_producto e id_proveedor son los culpables. Tienen la necesidad imperiosa de cambiarle los nombres a algo mas pequeño como id_prod e id_prov:

mysql> ALTER TABLE producto CHANGE COLUMN id_producto id_prod INT(6);
Query OK, 4 rows affected (0.09 sec)
Records: 4  Duplicates: 0  Warnings: 0
mysql> ALTER TABLE producto CHANGE COLUMN id_proveedor id_prov INT(6);
ERROR 1025 (HY000): Error on rename of './Prueba/#sql-7c65_2f' \
       to './/producto' (errno: 150)

¿Pero que clase de brujería es esta? ¿Porqué no pude cambiar el nombre de id_proveedor a id_prov? recordemos que id_proveedor es una clave foránea y si le cambiamos el nombre ya no estarán enlazadas las dos tablas, por lo tanto lo que debemos hacer es quitarle el status de clave foránea y cambiarle el nombre (en este caso voy a aprovechar de cambiarle el nombre a la clave primaria de la tabla proveedor tambien antes de rehacer el enlace):

mysql> ALTER TABLE producto DROP FOREIGN KEY fk_id_proveedor;
Query OK, 4 rows affected (0.09 sec)
Records: 4  Duplicates: 0  Warnings: 0
mysql> ALTER TABLE producto CHANGE COLUMN id_proveedor id_prov INT(6);
Query OK, 4 rows affected (0.08 sec)
Records: 4  Duplicates: 0  Warnings: 0
mysql> ALTER TABLE proveedor CHANGE COLUMN id_proveedor id_prov INT(6);
Query OK, 5 rows affected (0.07 sec)
Records: 5  Duplicates: 0  Warnings: 0
mysql> ALTER TABLE producto ADD constraint fk_id_prov FOREIGN KEY\
       (id_prov) REFERENCES proveedor(id_prov);
Query OK, 4 rows affected (0.07 sec)
Records: 4  Duplicates: 0  Warnings: 0
mysql> SELECT * FROM producto;
+---------+---------+---------------+-----------------------+------+
| id_prod | id_prov | nombre        | descripcion           | disp |
+---------+---------+---------------+-----------------------+------+
|       1 |       5 | jabón azul    | jabón para lavar      |  150 |
|       2 |       2 | Caucho radial | Caucho antiresbalante |  250 |
|       3 |       1 | Champú        | Champú anticaspa      |    0 |
|       4 |       4 | Caucho liso   | Caucho resbalante     |  589 |
+---------+---------+---------------+-----------------------+------+
4 rows in set (0.00 sec)

mysql> SELECT * FROM proveedor;
+---------+--------------------+-----------------------------------------+
| id_prov | nombre             | dirección                               |
+---------+--------------------+-----------------------------------------+
|       1 | Palmolive          | Calle los dos ríos, Desierto del Sahara |
|       2 | Goodyear           | Calle seca, Mar Caribe                  |
|       3 | Av. la piscina     | sector sin agua                         |
|       4 | Badyear            | Sin dirección                           |
|       5 | Procter and Gamble | En su casa                              |
+---------+--------------------+-----------------------------------------+
5 rows in set (0.00 sec)

Problema resuelto ya la tabla cabe en su blog :P.
Vamos a tocar el tema de como borrar entradas en una tabla, para esto requerimos el comando DELETE, su sintaxis es similar a SELECT: DELETE FROM nombre_table WHERE columna=valor;. Ejemplo: si deseo eliminar el producto caucho resbalante que posee el id_prod 4 usaría:

mysql> DELETE FROM producto WHERE id_prod=4;
Query OK, 1 row affected (0.02 sec)

Al igual que SELECT se pueden realizar subqueries y utilizar los operadores lógicos OR y AND.
Si en cambio queremos borrar una base de datos o una columna usamos el comando DROP cuya sintaxis es: DROP [DATABASE|TABLE], si se usa en conjunto con ALTER puede borrar columnas. Si por ejemplo deseo eliminar la columna disp de la tabla producto realizo lo siguiente:

mysql> ALTER TABLE producto DROP disp;
Query OK, 3 rows affected (0.10 sec)
Records: 3  Duplicates: 0  Warnings: 0

mysql> SELECT * FROM producto;
+---------+---------+---------------+-----------------------+
| id_prod | id_prov | nombre        | descripcion           |
+---------+---------+---------------+-----------------------+
|       1 |       5 | jabón azul    | jabón para lavar      |
|       2 |       2 | Caucho radial | Caucho antiresbalante |
|       3 |       1 | Champú        | Champú anticaspa      |
+---------+---------+---------------+-----------------------+
3 rows in set (0.00 sec)

Ahora requiero borrar la tabla producto completa:

mysql> mysql> DROP TABLE producto;
Query OK, 0 rows affected (0.03 sec)
mysql> SELECT * FROM producto;
ERROR 1146 (42S02): Table 'Prueba.producto' doesn't exist

Por último para borrar una base de datos debemos usar DROP DATABASE como en el ejemplo siguiente:

mysql> DROP DATABASE Prueba;
Query OK, 1 row affected (0.00 sec)
mysql> SHOW DATABASES;
+--------------------+
| Database           |
+--------------------+
| information_schema |
| mysql              |
| performance_schema |
+--------------------+
3 rows in set (0.00 sec)

EOF