2.1.8 Comandos generales de alta y baja del DBMS.

Objetivo:
Crear y utilizar bases de datos con MySQL en lnea de comandos y otorgar permisos a
usuarios sobre el sistema de base de datos.

El administrar y manejar bases de datos es muy importante en nuestros das ya que es
una herramienta fundamental y que tiene gran utilidad en nuestro mundo actual y
cotidiano. Las bases de datos las utilizan en cualquier lugar a donde vayamos como en la
tienda de discos, en la compra de un boleto electrnico y en las oficinas pblicas y
privadas etc.

MySQL es un administrador de base de datos ya que controla tanto a los usuarios y a las
bases de datos. MySQL trabaja en base a permisos de usuarios.

Los permisos de los usuarios se dan a distintos niveles:

1ro. Nivel usuario.
2do. Nivel base de datos.
3ro. Nivel mquina.
4to. Nivel tabla.
5to. Nivel campo.

Usted decide el nivel de seguridad que debe de tener segn la importancia de la
informacin que se maneje en las mismas bases de datos.

Para el uso de las bases de datos as como para el administrador de la misma, es
importante que tenga el conocimiento para crearla desde el mando de lnea ya que se da
el caso de que no est disponible el administrador grfico, por lo que iniciaremos con los
mandos de lnea.

Para acceder al administrador de MySQL se realizar de la siguiente manera:

mysql u nombre_del_usuario p password

Tambin en caso, de que no se desee dar el password en el mando de lnea se realizar
de la siguiente manera el acceso, primero da el usuario solamente y presiona enter
despus el administrador de mysql solicitar el password.

mysql u nombre_del_usuario p
password

Una vez entrado estaremos listos para iniciar el trabajo dentro del motor de MySQL en
este caso aparecer

mysql>aqu se escriben todas las instrucciones de uso.



Despus de haberse conectado, puede desconectarse en cualquier momento escribiendo
QUIT (o \q) en el prompt:

mysql> QUIT
Bye



Cuando ya se encuentra en el prompt de MySQL podemos crear una base de datos con la
instruccin:

mysql>create database nombre de la base de datos;

Ejemplo:

mysql>create database escuela;

Visualizar las bases de datos creadas es:

mysql>show databases;

Una vez creadas las bases de datos y para iniciar el trabajo con ella, es necesario ponerla
en uso. Esto es para que se comprueben los permisos que tienen el usuario que acceso
sobre la base de datos en particular.

Instruccin para poner en uso la base de datos:

mysql>use nombre de la base de datos

Ejemplo:

mysql>use escuela;

Sintaxis para crear una tabla:

CREATE [TEMPORARY] TABLE [IF NOT EXISTS] tbl_name
(create_definition,...)
[table_options]
Or:
CREATE [TEMPORARY] TABLE [IF NOT EXISTS] tbl_name
[(create_definition,...)]
[table_options]
select_statement
Or:
CREATE [TEMPORARY] TABLE [IF NOT EXISTS] tbl_name
{ LIKE old_tbl_name | (LIKE old_tbl_name) }
create_definition:
col_name column_definition
| [CONSTRAINT [symbol]] PRIMARY KEY [index_type] (index_col_name,...)
| {INDEX|KEY} [index_name] [index_type] (index_col_name,...)
| [CONSTRAINT [symbol]] UNIQUE [INDEX|KEY]
[index_name] [index_type] (index_col_name,...)
| {FULLTEXT|SPATIAL} [INDEX|KEY] [index_name] (index_col_name,...)
| [CONSTRAINT [symbol]] FOREIGN KEY
[index_name] (index_col_name,...) reference_definition
| CHECK (expr)

column_definition:
data_type [NOT NULL | NULL] [DEFAULT default_value]
[AUTO_INCREMENT] [UNIQUE [KEY] | [PRIMARY] KEY]
[COMMENT 'string'] [reference_definition]

data_type:
TINYINT[(length)] [UNSIGNED] [ZEROFILL]
| SMALLINT[(length)] [UNSIGNED] [ZEROFILL]
| MEDIUMINT[(length)] [UNSIGNED] [ZEROFILL]
| INT[(length)] [UNSIGNED] [ZEROFILL]
| INTEGER[(length)] [UNSIGNED] [ZEROFILL]
| BIGINT[(length)] [UNSIGNED] [ZEROFILL]
| REAL[(length,decimals)] [UNSIGNED] [ZEROFILL]
| DOUBLE[(length,decimals)] [UNSIGNED] [ZEROFILL]
| FLOAT[(length,decimals)] [UNSIGNED] [ZEROFILL]
| DECIMAL[(length[,decimals])] [UNSIGNED] [ZEROFILL]
| NUMERIC[(length[,decimals])] [UNSIGNED] [ZEROFILL]
| DATE
| TIME
| TIMESTAMP
| DATETIME
| YEAR
| CHAR[(length)]
[CHARACTER SET charset_name] [COLLATE collation_name]
| VARCHAR(length)
[CHARACTER SET charset_name] [COLLATE collation_name]
| BINARY[(length)]
| VARBINARY(length)
| TINYBLOB
| BLOB
| MEDIUMBLOB
| LONGBLOB
| TINYTEXT [BINARY]
[CHARACTER SET charset_name] [COLLATE collation_name]
| TEXT [BINARY]
[CHARACTER SET charset_name] [COLLATE collation_name]
| MEDIUMTEXT [BINARY]
[CHARACTER SET charset_name] [COLLATE collation_name]
| LONGTEXT [BINARY]
[CHARACTER SET charset_name] [COLLATE collation_name]
| ENUM(value1,value2,value3,...)
[CHARACTER SET charset_name] [COLLATE collation_name]
| SET(value1,value2,value3,...)
[CHARACTER SET charset_name] [COLLATE collation_name]
| spatial_type

index_col_name:
col_name [(length)] [ASC | DESC]

index_type:
USING {BTREE | HASH}

reference_definition:
REFERENCES tbl_name (index_col_name,...)
[MATCH FULL | MATCH PARTIAL | MATCH SIMPLE]
[ON DELETE reference_option]
[ON UPDATE reference_option]

reference_option:
RESTRICT | CASCADE | SET NULL | NO ACTION

table_options:
table_option [[,] table_option] ...

table_option:
{ENGINE|TYPE} = engine_name
| AUTO_INCREMENT = value
| AVG_ROW_LENGTH = value
| [DEFAULT] CHARACTER SET = charset_name
| CHECKSUM = {0 | 1}
| [DEFAULT] COLLATE = collation_name
| COMMENT = 'string'
| DATA DIRECTORY = 'absolute path to directory'
| DELAY_KEY_WRITE = {0 | 1}
| INDEX DIRECTORY = 'absolute path to directory'
| INSERT_METHOD = { NO | FIRST | LAST }
| MAX_ROWS = value
| MIN_ROWS = value
| PACK_KEYS = {0 | 1 | DEFAULT}
| PASSWORD = 'string'
| RAID_TYPE = { 1 | STRIPED | RAID0 }
RAID_CHUNKS = value
RAID_CHUNKSIZE = value
| ROW_FORMAT = {DEFAULT|DYNAMIC|FIXED|COMPRESSED}
| UNION = (tbl_name[,tbl_name]...)

select_statement:
[IGNORE | REPLACE] [AS] SELECT ... (Some legal select statement)

Instruccin para crear una tabla:

mysql>create table nombre de la tabla(nombre de los atributos, tipo del atributo);

ejemplo:

mysql> create table alumnos(matricula int not null primary key, apaterno varchar(20),
amaterno varchar(20), nombre varchar(30));

Instruccin para visualizar las tablas creadas:

mysql> show tables;

Instruccin para visualizar los atributos y el tipo respectivo de cada atributo de la tabla:

mysql> describe nombre de la tabla;

Ejemplo:

mysql> describe alumnos;


Sentencias SQL:

Para insertar datos en las tablas se realiza con el SQL

mysql> insert into alumnos values (123,Flores,Maldonado,Javier);
mysql> insert into alumnos values (456,Vzquez,Rodrguez,Carlos);


Nota: Solo los atributos de tipo numrico se insertan sin comillas.

Para realizar bsquedas utilicemos el SQL:

Select nombre del campo From nombre de la tabla
Where condicin;

Ejemplo:

mysql> select * from alumnos;

Si es una consulta con condicin se escribe:

mysql> select * from alumnos where nombre=Carlos;

Para actualizar atributos es con la siguiente sentencia:

UPDATE nombre de la tabla SET Campo1=Valor1, Campo2=Valor2, ... CampoN=ValorN
WHERE Criterio;

Ejemplo:

mysql> update alumnos set apaterno=Velzquez where nombre=Carlos;

Para comprobar escriba:

mysql> select * from alumnos;

Para borrar informacin de los atributos es con la siguiente sentencia:

DELETE FROM nombre de la tabla WHERE condicin;

Ejemplo:

mysql> delete from alumnos where nombre=Javier;

Para comprobar escriba:

mysql> select * from alumnos;


Instruccin para borrar una tabla:

mysql> drop table alumnos;

Instruccin para borrar una base de datos:

mysql> drop database alumnos;









Integridad referencial en MySQL.

Claves primarias
Para entender lo que son las claves forneas, tal vez sea necesario entender primero lo
que son las claves primarias.

Es un hecho que las claves juegan un papel muy importante no slo en MySQL, sino en
cualquier base de datos relacional. De manera simple, las claves proporcionan una
manera rpida y eficiente de buscar datos en una tabla, adems de que permiten
preservar la integridad de los datos.

Una clave candidata es un campo, o una combinacin de campos, que identifican de
manera nica un registro de una tabla. stas no pueden contener valores nulos, y su valor
debe ser nico.

Una clave primaria es una clave candidata que ha sido diseada para identificar de
manera nica a los registros de una tabla a travs de toda la estructura de la base de
datos.

La seleccin de una clave primaria es muy importante en el diseo de una base de datos,
ya que es un elemento clave de los datos que facilita la unin de tablas y el concepto total
de una base de datos relacional.

Las claves primarias deben ser nicas y no nulas, de manera que garanticen que una fila
de una tabla pueda ser siempre referenciada a travs de su clave primaria.

MySQL requiere que se especifique NOT NULL para las columnas que se van a utilizar
como claves primarias al momento de crear una tabla.
Claves forneas e integridad referencial
Podemos decir de manera simple que integridad referencial significa que cuando un
registro en una tabla haga referencia a un registro en otra tabla, el registro
correspondiente debe existir. Por ejemplo, consideremos la relacin entre una tabla
cliente y una tabla venta.

venta
id_factura
id_cliente
cantidad


Para poder establecer una relacin entre dos tablas, es necesario asignar un campo en
comn a las dos tablas. Para este ejemplo, el campo id_cliente existe tanto en la tabla
cliente como en la tabla venta. La mayora de las veces, este campo en comn debe ser
una clave primaria en alguna de las tablas. Vamos a insertar algunos datos en estas
tablas.




cliente
id_cliente
nombre
Tabla cliente Tabla venta
Id_cliente nombre
1 Juan Penas
2 Pepe Toro



Hay dos registros en la tabla cliente, pero existen 3 id_cliente distintos en la tabla venta.
Habamos dicho que las dos tablas se relacionan con el campo id_cliente, por lo tanto,
podemos decir que Juan Penas tiene una cantidad de 23, y Pepe el Toro 81, sin embargo,
no hay un nombre que se corresponda con el id_cliente 3.

Las relaciones de claves forneas se describen como relaciones padre/hijo (en nuestro
ejemplo, cliente es el padre y venta es el hijo), y se dice que un registro es hurfano
cuando su padre ya no existe.

Cuando en una base de datos se da una situacin como esta, se dice que se tiene una
integridad referencial pobre (pueden existir otra clase de problemas de integridad).

Generalmente esto va ligado a un mal diseo, y puede generar otro tipo de problemas en
la base de datos, por lo tanto debemos evitar esta situacin siempre que sea posible.

En el pasado, MySQL no se esforzaba en evitar este tipo de situaciones, y la
responsabilidad pasaba a la aplicacin. Para muchos desarrolladores, esta no era una
situacin del todo grata, y por lo tanto no se consideraba a MySQL para ser usado en
sistemas "serios". Por supuesto, esta fue una de las cosas ms solicitadas en las
anteriores versiones de MySQL; que se tuviera soporte para claves forneas, para que
MySQL mantenga la integridad referencial de los datos.

Una clave fornea es simplemente un campo en una tabla que se corresponde con la
clave primaria de otra tabla. Para este ejemplo, el campo id_cliente en la tabla venta es la
clave fornea. Ntese que este campo se corresponde con el campo id_cliente en la tabla
cliente, en dnde este campo es la clave primaria.

Las claves forneas tienen que ver precisamente con la integridad referencial, lo que
significa que si una clave fornea contiene un valor, ese valor se refiere a un registro
existente en la tabla relacionada.

Claves forneas en MySQL
Estrictamente hablando, para que un campo sea una clave fornea, ste necesita ser
definido como tal al momento de crear una tabla. Se pueden definir claves forneas en
cualquier tipo de tabla de MySQL, pero nicamente tienen sentido cuando se usan tablas
del tipo InnoDB.

A partir de la versin 3.23.43b, se pueden definir restricciones de claves forneas con el
uso de tablas InnoDB. InnoDB es el primer tipo de tabla que permite definir estas
restricciones para garantizar la integridad de los datos.



Id_factura Id_cliente cantidad
1 1 23
2 3 39
3 2 81
Para trabajar con claves forneas, necesitamos hacer lo siguiente (Esto se hace si
MySQL no est configurado para trabajar con tablas InnoDB):

Crear ambas tablas del tipo InnoDB.
Usar la sintaxis FOREIGN KEY(campo_fk) REFERENCES nombre_tabla
(nombre_campo)
Crear un ndice en el campo que ha sido declarado clave fornea.

InnoDB no crea de manera automtica ndices en las claves forneas o en las claves
referenciadas, as que debemos crearlos de manera explcita. Los ndices son necesarios
para que la verificacin de las claves forneas sea ms rpida. A continuacin se muestra
como definir las dos tablas de ejemplo con una clave fornea. Antes de iniciar, crea la
base de datos empresa y ponla en uso.

CREATE TABLE cliente
(
id_cliente INT NOT NULL,
nombre VARCHAR(30),
PRIMARY KEY (id_cliente)
) TYPE = INNODB;


CREATE TABLE venta
(
id_factura INT NOT NULL,
id_cliente INT NOT NULL,
cantidad INT,
PRIMARY KEY(id_factura),
INDEX (id_cliente),
FOREIGN KEY (id_cliente) REFERENCES cliente(id_cliente)
) TYPE = INNODB;

La sintaxis completa de una restriccin de clave fornea es la siguiente:

[CONSTRAINT smbolo] FOREIGN KEY (nombre_columna, ...)
REFERENCES nombre_tabla (nombre_columna, ...)
[ON DELETE {CASCADE | SET NULL | NO ACTION
| RESTRICT}]
[ON UPDATE {CASCADE | SET NULL | NO ACTION
| RESTRICT}]

Las columnas correspondientes en la clave fornea y en la clave referenciada deben tener
tipos de datos similares para que puedan ser comparadas sin la necesidad de hacer una
conversin de tipos. El tamao y el signo de los tipos enteros debe ser el mismo. En las
columnas de tipo caracter, el tamao no tiene que ser el mismo necesariamente.

Si MySQL da un error cuyo nmero es el 1005 al momento de ejecutar una sentencia
CREATE TABLE, y el mensaje de error se refiere al nmero 150, la creacin de la tabla
fall porque la restriccin de la clave fornea no se hizo de la manera adecuada. De la
misma manera, si falla una sentencia ALTER TABLE y se hace referencia al error nmero
150, esto significa que la definicin de la restriccin de la clave fornea no se hizo
adecuadamente. A partir de la versin 4.0.13 de MySQL, se puede usar la sentencia
SHOW INNODB STATUS para ver una explicacin detallada del ltimo error que se
gener en relacin a la definicin de una clave fornea.

Si en una tabla, un registro contiene una clave fornea con un valor NULO, significa que
no existe ninguna relacin con otra tabla.

A partir de la versin 3.23.50, se pueden agregar restricciones de clave fornea a una
tabla con el uso de la sentencia ALTER TABLE. La sintaxis es:

ALTER TABLE nombre_tabla ADD [CONSTRAINT smbolo] FOREIGN KEY(...)
REFERENCES otra_tabla(...) [acciones_ON_DELETE][acciones_ON_UPDATE]

Por ejemplo, la creacin de la clave fornea en la tabla venta que se mostr anteriormente
pudo haberse hecho de la siguiente manera con el uso de una sentencia ALTER TABLE:

CREATE TABLE venta
(
id_factura INT NOT NULL,
id_cliente INT NOT NULL,
cantidad INT,
PRIMARY KEY(id_factura),
INDEX (id_cliente)
) TYPE = INNODB;

ALTER TABLE venta ADD FOREIGN KEY(id_cliente) REFERENCES cliente(id_cliente);

En las versiones 3.23.50 y menores no deben usarse las sentencias ALTER TABLE o
CREATE INDEX en tablas que ya tienen definidas restricciones de claves forneas o bien,
que son referenciadas en restricciones de claves forneas: cualquier sentencia ALTER
TABLE elimina todas las restricciones de claves forneas definidas para la tabla.

No debe usarse una sentencia ALTER TABLE en una tabla que est siendo referenciada,
si se quiere modificar el esquema de la tabla, se recomienda eliminar la tabla y volverla a
crear con el nuevo esquema. Cuando MySQL hace un ALTER TABLE, puede que use de
manera interna un RENAME TABLE, y por lo tanto, se confundan las restricciones de
clave fornea que se refieren a la tabla. Esta restriccin aplica tambin en el caso de la
sentencia CREATE INDEX, ya que MySQL la procesa como un ALTER TABLE.

Cuando se ejecute un script para cargar registros en una base de datos, es recomendable
agregar las restricciones de claves forneas va un ALTER TABLE. De esta manera no se
tiene el problema de cargar los registros en las tablas de acuerdo a un orden lgico (las
tablas referenciadas deberan ir primero).






Insercin de registros con claves forneas

La integridad referencial se puede comprometer bsicamente en tres situaciones: cuando
se est insertando un nuevo registro, cuando se est eliminando un registro, y cuando se
est actualizando un registro. La restriccin de clave fornea que hemos definido se
asegura que cuando un nuevo registro sea creado en la tabla venta, ste debe tener su
correspondiente registro en la tabla cliente.

Una vez que hemos creado las tablas, vamos a insertar algunos datos que nos sirvan
para demostrar algunos conceptos importantes:

mysql> INSERT INTO cliente VALUES(1,'Juan Penas');
Query OK, 1 row affected (0.05 sec)

mysql> INSERT INTO cliente VALUES(2,'Pepe el toro');
Query OK, 1 row affected (0.05 sec)

mysql> INSERT INTO venta VALUES(1,1,23);
Query OK, 1 row affected (0.03 sec)

mysql> INSERT INTO venta VALUES(3,2,81);
Query OK, 1 row affected (0.03 sec)

En este momento no hay ningn problema, sin embargo, vamos a ver qu sucede cuando
intentamos insertar un registro en la tabla venta que se refiera a un cliente no existente
cuyo id_cliente es 3:

mysql> INSERT INTO venta VALUES(2,3,39);
ERROR 1216: Cannot add or update a child row: a foreign key constraint fails

El hecho es que MySQL no nos permite insertar este registro, ya que el cliente cuyo
id_cliente es 3 no existe. La restriccin de clave fornea asegura que nuestros datos
mantienen su integridad. Sin embargo, qu sucede cuando eliminamos algn registro?.

Vamos a agregar un nuevo cliente, y un nuevo registro en la tabla venta, posteriormente
eliminaremos el registro de nuestro tercer cliente:

mysql> INSERT INTO cliente VALUES(3,'Pepe pecas');
Query OK, 1 row affected (0.05 sec)

mysql> INSERT INTO venta VALUES(2,3,39);
Query OK, 1 row affected (0.05 sec)

mysql> DELETE FROM cliente WHERE id_cliente=3;
ERROR 1217: Cannot delete or update a parent row: a foreign key constraint fails

Debido a nuestra restriccin de clave fornea, MySQL no permite que eliminemos el
registro de cliente cuyo id_cliente es 3, ya que se hace referencia a ste en la tabla venta.



De nuevo, se mantiene la integridad de nuestros datos. Sin embargo existe una forma en
la cual podramos hacer que la sentencia DELETE se ejecute de cualquier manera, y la
veremos brevemente, pero primero necesitamos saber cmo eliminar (quitar) una clave
fornea.

Eliminacin de una clave fornea

No podemos slo eliminar una restriccin de clave fornea como si fuera un ndice
ordinario. Veamos que sucede cuando lo intentamos.

mysql> ALTER TABLE venta DROP FOREIGN KEY;
ERROR 1005: Can't create table '.test#sql-228_4.frm' (errno: 150)

Para eliminar la clave fornea se tiene que especificar el ID que ha sido generado y
asignado internamente por MySQL a la clave fornea. En este caso, se puede usar la
sentencia SHOW CREATE TABLE para determinar dicho ID.

mysql> SHOW CREATE TABLE venta;
+--------+--------------------------------------------------------------------------+
| Table | Create Table |
+--------+--------------------------------------------------------------------------+
| venta | CREATE TABLE 'venta' ( |
| | 'id_factura' int(11) NOT NULL default '0', |
| | 'id_cliente' int(11) NOT NULL default '0', |
| | 'cantidad' int(11) default NULL, |
| | PRIMARY KEY ('id_factura'), |
| | KEY 'id_cliente' ('id_cliente'), |
| | CONSTRAINT '0_22' FOREIGN KEY ('id_cliente') |
| | REFERENCES 'cliente' ('id_cliente') ) TYPE=InnoDB |
+---------+-------------------------------------------------------------------------+
1 row in set (0.00 sec)
En nuestro ejemplo, la restriccin tiene el ID 0_22 (es muy probable que este valor sea
diferente en cada caso).

mysql> ALTER TABLE venta DROP FOREIGN KEY 0_22;
Query OK, 3 rows affected (0.23 sec)
Records: 3 Duplicates: 0 Warnings: 0

Eliminacin de registros con claves forneas

Una de las principales bondades de las claves forneas es que permiten eliminar y
actualizar registros en cascada.

Con las restricciones de clave fornea podemos eliminar un registro de la tabla cliente y a
la vez eliminar un registro de la tabla venta usando slo una sentencia DELETE. Esto es
llamado eliminacin en cascada, en donde todos los registros relacionados son
eliminados de acuerdo a las relaciones de clave fornea. Una alternativa es no eliminar
los registros relacionados, y poner el valor de la clave fornea a NULL (asumiendo que el
campo puede tener un valor nulo). En nuestro caso, no podemos poner el valor de nuestra
clave fornea id_cliente en la tabla venta, ya que se ha definido como NOT NULL. Las
opciones estndar cuando se elimina un registro con clave fornea son:

ON DELETE RESTRICT
ON DELETE NO ACTION
ON DELETE SET DEFAULT
ON DELETE CASCADE
ON DELETE SET NULL

ON DELETE RESTRICT es la accin predeterminada, y no permite una eliminacin si
existe un registro asociado, como se mostr en el ejemplo anterior. ON DELETE NO
ACTION hace lo mismo.

ON DELETE SET DEFAULT actualmente no funciona en MySQL - se supone que pone el
valor de la clave fornea al valor por omisin (DEFAULT) que se defini al momento de
crear la tabla.

Si se especifica ON DELETE CASCADE, y una fila en la tabla padre es eliminada,
entonces se eliminarn las filas de la tabla hijo cuya clave fornea sea igual al valor de la
clave referenciada en la tabla padre. Esta accin siempre ha estado disponible en
MySQL.

Si se especifica ON DELETE SET NULL, las filas en la tabla hijo son actualizadas
automticamente poniendo en las columnas de la clave fornea el valor NULL. Si se
especifica una accin SET NULL, debemos asegurarnos de no declarar las columnas en
la tabla como NOT NULL.

A continuacin se muestra un ejemplo de eliminacin en cascada:

mysql> ALTER TABLE venta ADD FOREIGN KEY(id_cliente)
-> REFERENCES cliente(id_cliente) ON DELETE CASCADE;
Query OK, 3 rows affected (0.23 sec)
Records: 3 Duplicates: 0 Warnings: 0

Vamos a ver cmo estn nuestros registros antes de ejecutar la sentencia DELETE:

mysql> SELECT * FROM cliente;

+--------------+------------------+
| id_cliente | nombre |
+--------------+------------------+
| 1 | Juan Penas |
| 2 | Pepe el toro |
| 3 | Pepe pecas |
+--------------+------------------+
3 rows in set (0.00 sec)





mysql> SELECT * FROM venta;

+--------------+--------------+------------+
| id_factura | id_cliente | cantidad |
+--------------+--------------+------------+
| 1 | 1 | 23 |
| 2 | 3 | 39 |
| 3 | 2 | 81 |
+--------------+--------------+------------+
3 rows in set (0.00 sec)

Ahora eliminaremos a Pepe Pecas de la base de datos:

mysql> DELETE FROM cliente WHERE id_cliente=3;
Query OK, 1 row affected (0.05 sec)

mysql> SELECT * FROM venta;
+--------------+--------------+------------+
| id_factura | id_cliente | cantidad |
+--------------+--------------+------------+
| 1 | 1 | 23 |
| 3 | 2 | 81 |
+---------------+-------------+------------+
2 rows in set (0.00 sec)

mysql> SELECT * FROM cliente;
+--------------+----------------+
| id_cliente | nombre |
+--------------+----------------+
| 1 | Juan Penas |
| 2 | Pepe el toro |
+--------------+----------------+
2 rows in set (0.00 sec)

Con la eliminacin en cascada, se ha eliminado el registro de la tabla venta al que estaba
relacionado Pepe Pecas.

Actualizacin de registros con claves forneas
Las opciones correspondientes a ON UPDATE estn disponibles a partir de la versin
4.0.8.

Estas opciones son muy similares cuando se ejecuta una sentencia UPDATE, en lugar de
una sentencia DELETE. Estas son:

ON UPDATE CASCADE
ON UPDATE SET NULL
ON UPDATE RESTRICT

Vamos a ver un ejemplo, pero antes que nada, tenemos que eliminar la restriccin de
clave fornea (debemos usar el ID especfico de nuestra tabla).

mysql> ALTER TABLE venta DROP FOREIGN KEY 0_26;
Query OK, 2 rows affected (0.22 sec)
Records: 2 Duplicates: 0 Warnings: 0

mysql> ALTER TABLE venta ADD FOREIGN KEY(id_cliente)
-> REFERENCES cliente(id_cliente) ON DELETE RESTRICT ON UPDATE CASCADE;
Query OK, 2 rows affected (0.22 sec)
Records: 2 Duplicates: 0 Warnings: 0

NOTA: Se debe especificar ON DELETE antes de ON UPDATE, ya que de otra manera
se recibir un error al definir la restriccin.

Ahora est lista la clave fornea para una actualizacin en cascada. Este es el ejemplo:

mysql> SELECT * FROM venta;
+--------------+--------------+------------+
| id_factura | id_cliente | cantidad |
+--------------+--------------+------------+
| 1 | 1 | 23 |
| 3 | 2 | 81 |
+--------------+--------------+------------+
2 rows in set (0.00 sec)

mysql> UPDATE cliente SET id_cliente=10 WHERE id_cliente=1;
Query OK, 1 row affected (0.05 sec)
Rows matched: 1 Changed: 1 Warnings: 0

mysql> SELECT * FROM venta;
+--------------+--------------+------------+
| id_factura | id_cliente | cantidad |
+--------------+--------------+------------+
| 1 | 10 | 23 |
| 3 | 2 | 81 |
+--------------+--------------+------------+
2 rows in set (0.00 sec)

En este caso, al actualizar el valor de id_cliente en la tabla cliente, se actualiza de manera
automtica el valor de la clave fornea en la tabla venta. Esta es la actualizacin en
cascada.








Un ejemplo ms

Observar y estudiar detenidamente el diagrama entidad/relacin de la figura que se
muestra a continuacin.



Queda como ejercicio al alumno verificar que a partir de este diagrama se genera un
cdigo SQL similar al mostrado a continuacin, que nos sirve para la creacin de las
tablas con sus correspondientes definiciones de claves forneas:

Considerar que se desean hacer eliminaciones y actualizaciones en cascada, y que en la
tabla poema_libro la clave primaria est formada por ambos campos (id_poema y
id_libro).

CREATE TABLE libro (
id_libro INT NOT NULL,
titulo VARCHAR(100) NULL,
precio NUMERIC(5,2) NULL,
PRIMARY KEY(id_libro)
) ;
CREATE TABLE escritor (
id_escritor INT NOT NULL,
nombre VARCHAR(30) NULL,
apellidos VARCHAR(40) NULL,
direccion VARCHAR(100) NULL,
PRIMARY KEY(id_escritor)
) ;

CREATE TABLE poema (
id_poema INT NOT NULL,
id_escritor INT NOT NULL,
titulo VARCHAR(50) NULL,
contenido TEXT NULL,
PRIMARY KEY(id_poema),
INDEX(id_escritor),
FOREIGN KEY(id_escritor) REFERENCES escritor(id_escritor)
ON DELETE CASCADE ON UPDATE CASCADE
);

CREATE TABLE poema_libro (
id_poema INT NOT NULL,
id_libro INT NOT NULL,
PRIMARY KEY(id_poema, id_libro),
INDEX (id_poema), INDEX(id_libro),
FOREIGN KEY(id_poema) REFERENCES poema(id_poema)
ON DELETE CASCADE ON UPDATE CASCADE,
FOREIGN KEY(id_libro) REFERENCES libro(id_libro)
ON DELETE CASCADE ON UPDATE CASCADE
);


Para dar permisos desde la lnea de comandos de MySQL a un
usuario.

Los comandos GRANT y REVOKE permiten a los administradores de sistemas crear
cuentas de usuario MySQL y darles permisos y quitarlos de las cuentas.
La informacin de cuenta de MySQL se almacena en las tablas de la base de
datos mysql .

Los permisos pueden darse en varios niveles:
Nivel global
Los permisos globales se aplican a todas las bases de datos de un servidor dado.
Estos permisos se almacenan en la tabla mysql.user.
GRANT ALL ON *.* y REVOKE ALL ON *.* otorgan y quitan slo permisos globales.

Nivel de base de datos
Los permisos de base de datos se aplican a todos los objetos en una base de datos
dada. Estos permisos se almacenan en las tablas mysql.db y mysql.host .
GRANT ALL ON db_name.* y REVOKE ALL ON db_name.* otorgan y quitan slo
permisos de bases de datos.
Nivel de tabla
Los permisos de tabla se aplican a todas las columnas en una tabla dada. Estos
permisos se almacenan en la tabla mysql.tables_priv.
GRANT ALL ON db_name.tbl_name y REVOKE ALL ON db_name.tbl_name
otorgan y quitan permisos slo de tabla.
Nivel de columna
Los permisos de columna se aplican a columnas en una tabla dada. Estos permisos se
almacenan en la tabla mysql.columns_priv. Usando REVOKE, debe especificar las
mismas columnas que se otorgaron los permisos.
Nivel de rutina
Los permisos CREATE ROUTINE, ALTER ROUTINE, EXECUTE, y GRANT se aplican
a rutinas almacenadas. Pueden darse a niveles globales y de base de datos. Adems,
excepto para CREATE ROUTINE, estos permisos pueden darse en nivel de rutinas
para rutinas individuales y se almacenan en la tabla mysql.procs_priv.

Para usar GRANT o REVOKE, debe tener el permiso GRANT OPTION, y debe tener los
permisos que est dando o quitando.

Para hacer fcil de quitar todos los permisos, MySQL 5.0 tiene la siguiente sintaxis, que
borra todos los permisos globales, de nivel de base de datos y de nivel de tabla para los
usuarios nombrados:

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

Para usar esta sintaxis REVOKE, debe tener el permiso CREATE USER global o el
permiso UPDATE para la base de datos mysql .








Se pueden crear cuentas con la instruccin GRANT

Ejemplo:

Grant select,insert,update,delete,create,drop
On nombre de la base de datos.*
To nombre del usuario@localhost
Identified by password del usuario;

Cuando se asignan permisos desde la lnea de comandos debe usarse la instruccin
FLUSH PRIVILEGES para que tomen efecto todos los cambios.

mysql> flush privileges;


Prctica para realizar:

Escribe las instrucciones correspondientes a los siguientes puntos y escribe el resultado
obtenido en la lnea de comandos de MySQL o inserta las pantallas con el resultado
obtenido en cada punto. Guarda la actividad en un archivo de Word y envala en la
plataforma.

1. Entrar al servidor de mysql con su nombre de usuario y password
2. Visualizar las bases de datos ya existentes en el servidor.
3. Poner en uso la base de datos llamada mysql.
4. Visualizar las tablas de la base de la base de datos mysql.
5. Visualizar los campos de la tabla user y db dicha tablas
6. Crear una base de datos llamada vcasas
7. Crear un usuario llamado con el siguiente formato: apellidomaterno+matricula.
8. Darle los siguientes permisos de select, insert, update, delete, create, drop al usuario
que creaste apellidomaterno+matricula y con la base de datos vcasas

9. Crear las siguientes tablas:
casa vendedor vend_casa
Id_casa id_ vendedor Id_casa
Nombre nombre_ vendedor id_ vendedor
Direccin
Nota: Observa que la tabla vend_casa tiene relacin con la tabla casa y la tabla
vendedor (utilice Constraint Foreng key)
10. Salir de la base de datos y mysql.
11. entra con el usuario que creaste apellidomaterno+matricula.
12. Inserta datos en las tablas. En la tabla casa 3 conjuntos de datos, en la de vendedor 2
y en la vend_casa por consecuencia.
13. Visualiza las tablas.
14. Visualiza los nombres de los campos y el tipo.
15. Visualiza la informacin de cada tabla.
16. Cambia de vendedor a una de las casas.
17. Borra toda la informacin de las tablas donde el vendedor sea el 2do que diste de alta.
18. Modifica los permisos del usuario quitndole el de insert a los permisos de la base de
datos.
19. Dar de alta la informacin de otra casa
20. Modifica los permisos del usuario quitndole el de select a los permisos de la base de
datos
21. Visualizar la informacin de cada una de las tablas.
22. Borra toda la informacin de las tablas
23. Borra la tabla
24. Borrar la base de datos
25. Modifica los permisos del usuario quitndole el de select a los permisos de la base de
datos.
26. Visualizar la informacin de cada una de las tablas.



Se puede almacenar el resultado en un fichero, luego transferirlo al ordenador de destino,
y cargar el fichero en la base de datos. Por ejemplo, para volcar una base de datos hacia
un fichero en el ordenador de origen:
C:\> mysqldump --quick nombre_bd | gzip > nombre_bd.contenidos.gz
(El fichero creado en este ejemplo est comprimido). Se debe transferir hacia el
ordenador de destino el fichero con el contenido de la base de datos y ejecutar estos
comandos all:
C:\> mysqladmin create nombre_bd
C:\> gunzip < nombre_bd.contenidos.gz | mysql nombre_bd
Tambin se puede emplear mysqldump y mysqlimport para transferir la base de datos.
Para tablas grandes, esto ser mucho ms rpido que simplemente utilizar mysqldump.
En los siguientes comandos, DUMPDIRrepresenta la ruta completa al directorio donde se
depositar la salida de mysqldump.
En primer lugar, crear el directorio para los ficheros de salida y volcar la base de datos:
C:\> mkdir DUMPDIR
C:\> mysqldump --tab=DUMPDIR nombre_bd
Luego, transferir los ficheros desde el directorio DUMPDIR hacia el directorio
correspondiente en el ordenador de destino, y all cargar los ficheros en MySQL:
C:\> mysqladmin create nombre_bd #
crea la base de datos
c:\> cat DUMPDIR/*.sql | mysql nombre_bd #
crea las tablas en la base de datos
c:\> mysqlimport nombre_bd DUMPDIR/*.txt #
carga los datos en las tablas

Adems, no hay que olvidar copiar la base de datos mysql, porque es la que contiene las
tablas de permisos. Posiblemente, los comandos en el ordenador de destino se deban
ejecutar como usuario root de MySQL hasta que la base de datos mysql est en su
lugar.
Luego de importar la base de datos mysql en el ordenador de destino,
ejecutar mysqladmin flush-privilegespara que el servidor vuelva a cargar la informacin
de la tabla de permisos.