APLICACION DE BASE DE DATOS EN MySQL PDF

APLICACIÓN DE
BASE DE DATOS
UNIVERSIDAD TÉCNICA DE MANABÍ
DEPARTAMENTO DE INFORMÁTICA Y ELECTRÓNICA
Ing. Gabriel Demera Ureta MgSc.
Josué 1:9
9
Mira que te mando que te esfuerces y seas valiente; no temas ni
desmayes, porque Jehová tu Dios estará contigo en dondequiera que
vayas.
PRÁCTICAS DE BASES DE DATOS

Las bases de datos en cualquier proyecto informático, empresa o institución, requiere de preparación en el
uso de las herramientas de gestión de la información, este documento es una fuente de conocimientos que
lo prepara para responder ante las necesidades de la administración de datos…
Aplicaciones de Base de Datos
TABLA DE CONTENIDO
PRESENTACION ..................................................................................................................................................... 4
ADMINISTRACIÓN DE MYSQL MEDIANTE CONSOLA ............................................................................................ 5
CONECCIÓN CON EL SERVIDOR MYSQL MEDIANTE CONSOLA ............................................................................. 6
COMANDOS A UTILIZAR DENTRO DE LA CONSOLA DE MYSQL............................................................................. 6
CREACIÓN DE TABLAS ........................................................................................................................................... 8
TIPOS DE DATOS DE MYSQL .................................................................................................................................. 8
ACTUALIZACIÓN DE LA ESTRUCTURA DE UNA TABLA ........................................................................................12
ACTIVIDADES DE DESARROLLO ...........................................................................................................................13
RELACIONES E INGRESOS DE DATOS...................................................................................................................13
PROCESOS DE INGRESOS DE DATOS EN LAS TABLAS CREADAS: .........................................................................14
PROCESOS DE EXTRACCIÓN DE DATOS EN LAS TABLAS CREADAS: ...................................................................15
CREACIÓN DE SUBCONSULTAS ...........................................................................................................................18
CREACIÓN DE CONSULTAS MULTI-TABLAS .........................................................................................................21
EJEMPLOS CON PRODUCTO CARTESIANO ..........................................................................................................25
VISTAS EN MySQL ...............................................................................................................................................28
USUARIOS Y PRIVILEGIOS....................................................................................................................................31
NIVELES DE PRIVILEGIOS .................................................................................................................................31
CREAR USUARIOS ................................................................................................................................................31
MOSTRAR LOS PRIVILEGIOS DE UN USUARIO.................................................................................................32
PARA CONCEDER PRIVILEGIOS ........................................................................................................................32
VARIACIONES PARA ACCESOS REMOTOS AL SERVIDOR DE BASE DE DATOS ..................................................35
PARA REVOCAR PRIVILEGIOS .........................................................................................................................35
PARA BORRAR USUARIOS ...............................................................................................................................36
PROCEDIMIENTOS ALMACENADOS ....................................................................................................................37
SENTENCIA DECLARE...................................................................................................................................39
SENTENCIA SET PARA VARIABLES ...............................................................................................................39
LA SENTENCIA CALL.....................................................................................................................................39
LA SENTENCIA SELECT ... INTO ....................................................................................................................39
SENTENCIA IF...............................................................................................................................................40
LA SENTENCIA CASE ....................................................................................................................................41
SENTENCIA LOOP ........................................................................................................................................42
SENTENCIA LEAVE .......................................................................................................................................43
LA SETENCIA ITERATE ..................................................................................................................................43
SENTENCIA REPEAT ....................................................................................................................................43
1 Ing. Gabriel Demera Ureta MgSc.

SENTENCIA WHILE.......................................................................................................................................44
FORMAS DE MOSTRAR EL LISTADO DE PROCEDIMIENTOS ALMACENADOS ..............................................45
FUNCIONES EN MYSQL .......................................................................................................................................49
COMO AGREGAR COMENTARIOS .......................................................................................................................52
CURSORES EN MYSQL .........................................................................................................................................53
TRANSACCIONES.....................................................................................................................................................58
OTRO EJEMPLO ...............................................................................................................................................60
TRIGGERS (Disparadores)....................................................................................................................................62
GESTIÓN EN LA ADMINISTRACIÓN DE MYSQL ....................................................................................................64
EXPORTACIÓN E IMPORTACION DE DATOS. .......................................................................................................64
ADMINISTRACIÓN DE CLAVES .............................................................................................................................67
CHEQUEAR EL ESTADO DEL SERVIDOR ...............................................................................................................68
USO DE ENCRIPTACIONES ...................................................................................................................................69
PARA ADMINISTRAR LOS RESPALDOS.................................................................................................................70
PARA IMPORTAR O RESTAURAR UN RESPALDO .................................................................................................70
REPLICACIONES ...................................................................................................................................................71
PARA ADMINISTRAR EL ESTADO DE LAS TABLAS ................................................................................................76
PERROR ...............................................................................................................................................................77
CHECK TABLE ...............................................................................................................................................77
REPAIR TABLE ..................................................................................................................................................78
PARA ADMINISTRAR EL ESTADO DE LAS BASE DE DATOS ..................................................................................79
ARCHIVOS DE BASE DE DATOS.......................................................................................................................81
ADMINISTRACIÓN DE LA EFICIENCIA DE UNA SENTENCIA SELECT .....................................................................82
EXPLAIN ......................................................................................................................................................82
PARTICIONES DE TABLAS ....................................................................................................................................84
CREAR PARTICIONES .......................................................................................................................................86
BORRAR PARTICIONES ....................................................................................................................................87
AÑADIR PARTICIONES .....................................................................................................................................87
CONSULTAR PARTICIONES ..............................................................................................................................87
ANEXO I (RESUMEN DE COMANDOS MYSQL) ....................................................................................................90
ANEXO II (OTROS EJEMPLOS DE USO DE 'ALTER TABLE' EN MYSQL) .................................................................92
ANEXO III (FUNCIONES DEL LENGUAJE DE MySQL) ...........................................................................................94
FUNCIONES DE CONTROL DE FLUJO ...............................................................................................................94
FUNCIONES MATEMÁTICAS ............................................................................................................................94
FUNCIONES DE CADENAS................................................................................................................................94
FUNCIONES DE COMPARACIÓN DE CADENAS ................................................................................................95

FUNCIONES DE FECHA ....................................................................................................................................95
DE BÚSQUEDA DE TEXTO ................................................................................................................................97
FUNCIONES DE CASTING (CONVERSIÓN DE TIPOS) ........................................................................................97
MISCELANEA ...................................................................................................................................................97
DE GRUPOS .....................................................................................................................................................97
ANEXO IV (ERRORES Y SUS CÓDIGOS) ................................................................................................................98
ANEXO V (Posibilidades de utilizar los permisos de usuarios en MySQL) ........................................................100

PRESENTACION
Este material académico de la cátedra de “Aplicación de Base de Datos”, explica los conceptos y
prácticas fundamentados en el modelo conceptual Entidad-Relación, utiliza en primera instancia a
MySQL, que es un Sistema Gestor de Bases de Datos (SGBD) relacional, multihilo y multiusuario,
aplica herramientas relacionadas con ese modelo, como la normalización y sus diferentes utilizades
prácticas en la gestión de los datos.
El presente documento es un compendio de muchas fuentes tomadas del Internet, incluyendo

páginas y sitios especializados, opiniones y conclusiones de miembros de la comunidad de MySQL,
así como aportanciones propias del docente autor de este material.
Esta domumentación tiene el propósito de introducir al estudiante o el interesado, a la

administración de MySQL y los diferentes recursos adicionales que ofrece esta báse de datos, El
contenido de este compendio, esta clasificado por áreas de estudio, conceptualiza y muestra con
ejemplos la gestión de los datos, tablas, usuarios, codificación almacenada y la propia base de
datos, incluye elementos administrativos que permiten analizar y tomar deciciones que permiten
gestionar, mantener y asegurar la base de datos, proporciona archivos de apoyo en formato de
texto, que le permitirán realizar las prácticas en cualquier computador que tenga instalado un
servidor de base de datos MySQL.

ADMINISTRACIÓN DE MYSQL MEDIANTE CONSOLA
Todos los sistemas de gestión de base de datos poseen aplicaciones gráficas, tipo explorador así
como los de introducción de comandos llamados consolas, el presente material introduce al
estudiante en la administración de las bases de datos mediante órdenes (comandos) en ambiente
de consolas, utiliza los sistemas de gestión de base de datos gratuitos y de gran uso en los
principales servidores del mundo.
La primera etapa contiene material de apoyo en MySQL y la segunda etapa en PostgreSQL, el

sistema de gestión de base de datos MySQL al igual que otras bases de datos posee una consola que
sirve para gestionar la base datos mediante el tipiado de comandos administrativos, a ésta se puede
acceder mediante un acceso directo proveído por el software o por la consola de Windows.
Sin importar cuál sea la consola que esté utilizando, el usuario deberá aprender comandos que son
interpretados por el SHELL que consiste en un compilador que entiende y ejecuta las órdenes
introducidas por el usuario.
Las prácticas propuestas en éste documento utiliza el Shell de Windows para acceder y ejecutar la
consola de MySQL, esto porque sus aplicaciones están organizadas y guardadas en carpetas
especiales, la ubicación de éstas carpetas pueden variar dependiendo del proveedor y la versión de
los servidores, por ejemplo, puede estar localizado en la raíz del disco C:, para ejecutar la consola de
MySQL en Windows, tendremos que estar situados dentro de la carpeta que contiene la aplicación.
Para el efecto práctico se utilizará el proveedor “Wamp Server” el cual al ser instalado se ubica en la
ruta:
C:\wamp\bin\mysql\mysql5.1.36\bin>_
Considere que la ruta especificada se accede mediante la consola de Windows y utilizando WAMP
que son iniciales de Windows Apache Mysql Php.
Esta aplicación incluye un acceso rápido con cualquiera de las siguientes apariencias:
En Linux, por supuesto, también se puede acceder a MySQL por línea de comandos. Posiblemente
desde cualquier carpeta podamos acceder a la consola de MySQL, sin necesidad de situarse en la
carpeta donde se instaló.

CONECCIÓN CON EL SERVIDOR MYSQL MEDIANTE CONSOLA
Lo primero que hay que considerar es la orden de acceso al sistema gestor de MySQL mediante
consola. Para ello, simplemente tenemos que escribir el comando "mysql" e indicarle unas opciones
de conexión.
% mysql
Con el signo "%" se expresa que puede ser cualquier Shell, ya sea en Windows o Linux. Ese
principio “%” se le denomina prontuario, que puede ser algo como lo indicado en la página anterior
(C:\wamp\bin\mysql\mysql5.1.36\bin>). El carácter "%", es considerado como una expresión
simbólica y no parte de los comandos.
Con la orden mysql se puede conectar con el servidor de la base de datos local o remota, considere
que ésta orden obligatoriamente estará acompañada de parámetros que definen los
comportamientos de acceso al servidor, es decir, incluye comportamientos como nombre del
usuario, password de seguridad, nombre de la base de datos a la que desea acceder, acceso al
servidor local o remoto, entre otros.
La sintaxis modelo sería la siguiente:

% mysql -h nombre_servidor -u nombre_usuario -p
Sí se desea conectar al servidor local se utiliza el parámetro “-h localhost”, si es un servidor remoto
“-h dirección IP del Host”, por ahora se utilizará como nombre de usuario “–u root”, para escribir la
clave de acceso se debe especificar “-p” de lo que significa que se tendría que escribir:
% mysql -h localhost -u root -p
Una vez introducida la clave, ya estará dentro del Shell de la consola de MySQL. Con ello el
prontuario cambiará a algo como esto:
mysql>
Se podría haber indicado la contraseña directamente en la línea de comandos que accede a la

consola del servidor pero esto se desaconseja por razones de seguridad, en caso de querer hacerlo,
la sintaxis sería:
% mysql -h localhost -u root -pmi_clave
Note que entre -h y el nombre del host hay un espacio en blanco, igual que entre -u y el nombre de
usuario; sin embargo, entre -p y la clave no se debe poner ningún espacio.
COMANDOS A UTILIZAR DENTRO DE LA CONSOLA DE MYSQL
Una vez que se ha accedido al servidor, el Shell de la consola dispone de muchas sentencias que
permiten administrar las bases de datos de MySQL y sus elementos, es importante destacar que el
estándar SQL como lenguaje posee órdenes que también pueden ser aplicadas en la consola.
Todos los servidores de base de datos poseen una base de datos administrativa, la cual posee tablas
que registrar la organización y estructura de las bases de datos que crean los usuarios, tablas,
usuarios, accesos y restricciones, procedimientos almacenados, entre otros.
Para conectarte con una base de datos en concreto se hace uso del comando “use”, seguido del
nombre de la base de datos que deseas conectarse, su sintaxis es:
mysql> use mibasedatos;
Esto nos conectaría con la base de datos llamada "mibasedatos", para el ejemplo nos conectaremos
con la base de datos administrativa:
mysql> use mysql;
Es importante notar que todas las sentencias dentro del Shell de MySQL terminan en ";". Si no se
coloca el punto y coma, lo más seguro es que NO se ejecute el comando y vuelva a salir el
prontuario solicitando que sigamos introduciendo el comando. Si lo que se deseaba era ejecutar la
sentencia, con simplemente entrar el ";" será suficiente. Es decir, no se debe escribir de nuevo la
sentencia entera, sólo el ";" y volver a presionar la tecla "enter".
Si se desea ver la lista de las bases de datos alojadas en el servidor, se debe escribir el comando
show databases de la siguiente forma:
mysql>show databases;
Con esto se mostraría una lista de las bases de datos del servidor, para el ejemplo algo como esto:
mysql> show databases
-> ;
5 rows in set (0.02 sec)
Para crear una base datos, se debe escribir el comando "create database" seguido del nombre de la
nueva base de datos.
mysql> create database miprueba;
La consola de Mysql permite agregar una variante que evita mostrar errores en caso de que la base
de datos ya exista:
mysql>create database IF NOT EXISTS miprueba;
En cualquiera de los ejemplos anteriores se creará una base de datos llamada "miprueba", para
acceder a ella se utiliza:
mysql> use miprueba;
Lógicamente, esta base de datos recién creada estará vacía, pero si se estuviera usando una base de
datos ya creada, se podría utilizar el comando "show tables" para ver el listado de tablas.
mysql> show tables;
Si no hay tablas, se mostraría algo como "Empty set", pero si tenemos varias tablas en la base de
datos, se mostrará una lista de ellas, para ver el listado de tablas que posee la base de dados
administrativa escriba:
mysql> show tables;

Ahora, si desea obtener información sobre una tabla, para saber qué campos tiene y de qué tipos
de datos, se puede utilizar el comando describe seguido del nombre de la tabla, por ejemplo:
mysql> describe administrador;
Otra alternativa para mostrar la estructura de una tabla es la siguiente:

SHOW FULL COLUMNS FROM tabla;
PARA SALIR DE LA CONSOLA DE COMANDOS DE MYSQL
En algunas ocasiones, usted tendrá la necesidad de salir de la consola y volver entrar para probar el
uso de instrucciones administrativas en MySQL, o simplemente desea salir ya que ha terminado de
trabajar con el servidor de MySQL, solo basta con escribir la instrucción "quit;" o “\q”, para el
ejemplo:
mysql> quit
CREACIÓN DE TABLAS
Una tabla es un elemento de la base de datos que es utilizada para registrar, organizar y presentarla
en cualquier formato en forma de listado. Las tablas se componen de filas (registros o tuplas) y
columnas (Campos o atributos) de celdas que se pueden rellenar con información, las tablas se
componen de dos estructuras:
Registro: se la podría definir como una fila que contiene datos con la misma relación
informacional, diferenciada de las otras filas. Ejemplo: en una tabla que tiene columnas
como nombres y direcciones, cada fila contendrá un nombre y una dirección de personas
diferentes.
Campo: es cada una de las columnas que forman la tabla. Contienen datos e información de
tipo diferente a los de otros campos; considerando el ejemplo anterior, cada campo
contendrá un tipo de datos único, como una dirección, o un número de teléfono, un
nombre, etc, es importante destacar que no puede haber dos campos que almacenen la
misma información.
Cada tabla creada debe tener un nombre único en la cada Base de Datos, haciéndola accesible
mediante su nombre o su seudónimo (Alias). Las tablas son los objetos principales de bases de
datos que se utilizan para guardar gran cantidad de información.
TIPOS DE DATOS DE MYSQL
Después de la fase de diseño de una base de datos, en necesario crear las tablas correspondientes
dentro de la base de datos. Para cada campo o columna de cada una de las tablas, es necesario
determinar el tipo de datos que contendrá y conseguir un almacenamiento óptimo con la menor

utilización de espacio. Los tipos de datos que puede haber en un campo, se pueden agrupar en tres
grandes grupos que numeramos a continuación:
1.- TIPOS DE DATOS NUMÉRICOS:

Existen tipos de datos numéricos, que se pueden dividir en dos sub grupos, los que están en
coma flotante (con decimales) y los que no (enteros).
TinyInt: es un número entero con o sin signo. Con signo el rango de valores válidos va desde
-128 a 127. Sin signo, el rango de valores es de 0 a 255
Bit ó Bool: un número entero que puede ser 0 ó 1
SmallInt: número entero con o sin signo. Con signo el rango de valores va desde -32768 a
32767. Sin signo, el rango de valores es de 0 a 65535.
MediumInt: número entero con o sin signo. Con signo el rango de valores va desde -
8.388.608 a 8.388.607. Sin signo el rango va desde 0 a16777215.
Integer, Int: número entero con o sin signo. Con signo el rango de valores va desde -
2147483648 a 2147483647. Sin signo el rango va desde 0 a 429.4967.295
BigInt: número entero con o sin signo. Con signo el rango de valores va desde -
9.223.372.036.854.775.808 a 9.223.372.036.854.775.807. Sin signo el rango va desde 0 a
18.446.744.073.709.551.615.
Float: número pequeño en coma flotante de precisión simple. Los valores válidos van desde -
3.402823466E+38 a -1.175494351E-38, 0 y desde 1.175494351E-38 a 3.402823466E+38.
xReal, Double: número en coma flotante de precisión doble. Los valores permitidos van
desde -1.7976931348623157E+308 a -2.2250738585072014E-308, 0 y desde
2.2250738585072014E-308 a 1.7976931348623157E+308
Decimal, Dec, Numeric: Número en coma flotante desempaquetado. El número se almacena
como una cadena
2.- TIPOS DE DATOS PARA FECHA:
A la hora de almacenar fechas, hay que tener en cuenta que Mysql no comprueba de una
manera estricta si una fecha es válida o no. Simplemente comprueba que el mes está
comprendido entre 0 y 12 y que el día está comprendido entre 0 y 31.
Date: tipo fecha, almacena una fecha. El rango de valores va desde el 1 de enero del 1001 al
31 de diciembre de 9999. El formato de almacenamiento es de año-mes-dia
DateTime: Combinación de fecha y hora. El rango de valores va desde el 1 de enero del 1001
a las 0 horas, 0 minutos y 0 segundos al 31 de diciembre del 9999 a las 23 horas, 59 minutos
y 59 segundos. El formato de almacenamiento es de año-mes-dia horas:minutos:segundos
TimeStamp: Combinación de fecha y hora. El rango va desde el 1 de enero de 1970 al año

2037. El formato de almacenamiento depende del tamaño del campo:

TAMAÑO FORMATO
14 AñoMesDiaHoraMinutoSegundo
aaaammddhhmmss
12 AñoMesDiaHoraMinutoSegundo
aammddhhmmss
8 ñoMesDia aaaammdd
6 AñoMesDia aammdd
4 AñoMes aamm
2 Año aa
Time: almacena una hora. El rango de horas va desde -838 horas, 59 minutos y 59 segundos
a 838, 59 minutos y 59 segundos. El formato de almacenamiento es de 'HH:MM:SS'
Year: almacena un año. El rango de valores permitidos va desde el año 1901 al año 2155. El
campo puede tener tamaño dos o tamaño 4 dependiendo de si queremos almacenar el año
con dos o cuatro dígitos.
TIPO DE TAMAÑO DE
CAMPO ALMACENAMIENTO
DATE 3 bytes
DATETIME 8 bytes
TIMESTAMP 4 bytes
TIME 3 bytes
YEAR 1 byte
3.- TIPOS DE DATOS PARA CADENAS DE TEXTO:
Char(n): almacena una cadena de longitud fija. La cadena podrá contener desde 0 a 255
caracteres.
VarChar(n): almacena una cadena de longitud variable. La cadena podrá contener desde 0 a
255 caracteres.
Dentro de los tipos de cadena se pueden distinguir otros dos subtipos, los tipo Test y los tipo
BLOB (Binary large Object)
La diferencia entre un tipo y otro es el tratamiento que reciben a la hora de realizar
ordenamientos y comparaciones. Mientras que el tipo test se ordena sin tener en cuenta las
Mayúsculas y las minúsculas, el tipo BLOB se ordena teniéndolas en cuenta.
Los tipos BLOB se utilizan para almacenar datos binarios como pueden ser ficheros.
TinyText y TinyBlob: Columna con una longitud máxima de 255 caracteres.
Blob y Text: un texto con un máximo de 65535 caracteres.
MediumBlob y MediumText: un texto con un máximo de 16.777.215 caracteres.
LongBlob y LongText: un texto con un máximo de caracteres 4.294.967.295. Hay que tener
en cuenta que debido a los protocolos de comunicación los paquetes pueden tener un
máximo de 16 Mb.
Enum: campo que puede tener un único valor de una lista que se especifica. El tipo Enum
acepta hasta 65535 valores distintos

Set: un campo que puede contener ninguno, uno ó varios valores de una lista. La lista puede
tener un máximo de 64 valores.
TIPO DE CAMPO TAMAÑO DE ALMACENAMIENTO
CHAR(n) n bytes
VARCHAR(n) n +1 bytes
TINYBLOB, TINYTEXT Longitud+1 bytes
BLOB, TEXT Longitud +2 bytes
MEDIUMBLOB, MEDIUMTEXT Longitud +3 bytes
LONGBLOB, LONGTEXT Longitud +4 bytes
ENUM('value1','value2',...) 1 ó dos bytes dependiendo del número
de valores
SET('value1','value2',...) 1, 2, 3, 4 ó 8 bytes, dependiendo del
número de valores
Diferencia de almacenamiento entre los tipos Char y VarChar
VALOR CHAR(4) ALMACE VARCHAR(4) ALMACE

NAMIENTO NAMIENTO
'' '' 4 bytes " 1 byte
'ab' 'ab ' 4 bytes 'ab' 3 bytes
'abcd' 'abcd' 4 bytes 'abcd'
'abcdefgh' 'abcd' 4 bytes 'abcd' 5 bytes
La sintaxis general para crear una tabla es:

CREATE TABLE nombre_tabla
(nombre_campo1 TIPO_COLUMNA(),
nombre_campo1 TIPO_COLUMNA(),
nombre_campo1 TIPO_COLUMNA(), …..
);
Supongamos que se desea crear una tabla con el nombre de “PRUEBA” cuya clave primaria es id
(una clave primaria es un campo que identifica unívocamente los registros de una tabla) que va
incrementando su valor automáticamente, cada vez que insertamos un nuevo registro en la tabla,
un campo nombre que es de tipo cadena de caracteres con límite máximo de 60 caracteres y un
campo sexo que es de tipo cadena de caracteres que solo almacenará M o F (Masculino y
Femenino):
CREATE TABLE prueba(
id int NOT NULL AUTO_INCREMENT,
nombre VARCHAR(60) default NULL,
sexo VARCHAR(1),
PRIMARY KEY (id)
) TYPE=INNODB;
MySQL posee varias ingenierías de administración de datos que se aplican a las tablas de una base
de datos, INNODB es uno de ellos y se encuentra entre los más populares al igual que MyISAM,
cuando no se especifica en la creación de una tabla tomará la ingeniería por defecto MyISAM, es
importante destacar que existe compatibilidad entre ellas salvo algunas excepciones que se
detallarán más adelante en el capítulo de administración de base de datos, para el ejemplo
TYPE=INNODB es para especificar el tipo de ingeniería de base de datos que utilizará para crear la
tabla, sí desea crear una tabla utilizando el motor que se encuentra ejecutando por defecto, lo haría
como el siguiente ejemplo:
CREATE TABLE usuario (
id_usuario INT PRIMARY KEY AUTO_INCREMENT,
nombre VARCHAR(50) NOT NULL,
direccion VARCHAR(50) NOT NULL,
ciudad VARCHAR(20) NOT NULL,
edad TINYINT NOT NULL
);
ACTUALIZACIÓN DE LA ESTRUCTURA DE UNA TABLA
Durante el desarrollo de creación y puesta en marcha de una base de datos, tendrá que realizar
algunos ajustes para optimizar el recurso de almacenamiento, esta documentación propone algunos
ejemplos:
 Asumiendo que se le olvidó crear un campo fecha de registro a la tabla usuario, usted tendría
que utilizar el comando ALTER TABLE para modificar su diseño de la siguiente forma:
ALTER TABLE usuario ADD Fecha_Registro DATE;
DESCRIBE usuario;
 Para añadir un campo 'email' como un índice del tipo único (restricción que valida la NO
existencia de contenidos iguales), se tendría que hacer:
ALTER TABLE usuario ADD email varchar(50);
ALTER TABLE usuario ADD UNIQUE(email);
DESCRIBE usuario;
 Para modifica el tamaño de la columna email, se puede utilizar:

ALTER TABLE usuario MODIFY email varchar(150);
DESCRIBE usuario;
 Para cambia el nombre de la columna 'ciudad' al nuevo nombre ' accesos_permitidos' que
incluye la definición hasta del tipo de datos, se tendría que realizar:
ALTER TABLE usuario CHANGE ciudad accesos_permitidos int(4);
DESCRIBE usuario;
 Para cambia solo el tipo de datos de la columna 'edad' y especificarle que no admita datos
vacíos (nulos), entonces tendría que realizar:
ALTER TABLE usuario MODIFY edad FLOAT(6,2) NOT NULL;
 En la tabla ejemplo, cualquier campo que tenga en su definición la propiedad

'AUTO_INCREMENT' (en una tabla solo un campo podrá incluirla), podrá cambiarse el valor
inicial, asumiendo que los registros comenzarán a partir de '1000' o cualquier número indicado,

considerando que no es posible utilizar un valor ya existente en un registro, usted podrá

cambiarlo de la siguiente forma:
1. ALTER TABLE usuario AUTO_INCREMENT=1000;
2. INSERT INTO usuario(nombre,direccion,accesos_permitidos,edad,Fecha_Registro,email)
VALUES (‘Carlos’,’portoviejo’,20,16,’2013-09-26’,’jcmontero1254@utm.edu.ec’);
3. SELECT * FROM usuario;
Al aplicar la sentencia de la línea numerada 3, notará que el primer registro ya no empezará por
el índice 1 sino que comenzará por el 1000.
 Para eliminar la columna 'edad' de la tabla 'usuario', usted tendría que realizar lo siguiente:
ALTER TABLE usuario DROP COLUMN edad;
DESCRIBE usuario;
 Para eliminar varias columnas se utilizará la siguiente sintaxis:

ALTER TABLE Nombre_Tabla DROP COLUMN campo1, DROP COLUMN campo2;
TAREA 3: Elabore la creación de una tabla que permita registrar los datos de vehículos en una
cooperativa de transporte inter cantonal, asumiendo que necesita modificarla aplique 5 comandos
ALTER TABLE para justificar los cambios, puede utilizar los modelos ejemplificados en este
documento pero es recomendable que investigue y aplique nuevos modelos.
ACTIVIDADES DE DESARROLLO
La presente documentación utilizará el diseño y creación de una base de datos llamada “UNIDAD”,
que le permite gestionar datos e información de una unidad educativa ficticia, este material se
respalda en archivos de texto que le permitirá utilizar de forma comprimida los ejemplos aquí
descritos.
RELACIONES E INGRESOS DE DATOS
CREAR RELACIONES Y CLAVES FORANEAS
El fundamento básico del modelo entidad relación, que propone los sistemas de gestión de base de
datos, de basa en la posibilidad de crear relaciones entre tablas, la definición propuesta por MySQL
en general utiliza la sintaxis:
FOREIGN KEY (campo_fk) REFERENCES nombre_tabla(nombre_campo)
Es recomendable crear un índice en el campo que ha sido declarado como clave foránea, para
mejorar los tiempos de búsqueda.
Para ejemplificar la creación de una base de datos con sus respectivas tablas relacionadas, se
tomará como referencia el almacenamiento de registros datos para una unidad educativa, para el
siguiente análisis, considere que un estudiante puede ser con el pasar del tiempo un padre de
familia, o un docente de la misma institución:

DROP DATABASE IF EXISTS Unidad;

Create Database if not exists Unidad;
use Unidad;
create table if not exists padres(

IdPersona int,
cargasfamiliares int(2),
create table if not exists personas( TelefonoTrabajo varchar(15),
IdPersona int primary key auto_increment, DireccionTrabajo varchar(100),
ApellidoPaterno Varchar(50) not null, ocupacion varchar(80),
ApellidoMaterno Varchar(50) not null, index(Idpersona),
Nombres Varchar(50) not null, FOREIGN key(IdPersona) references
Direccion Varchar(150), personas(Idpersona)
telefono Varchar(15), );
sexo enum('M','F'),
FechaNacimiento date, create table if not exists Estudiante(
EstadoCivil IdPersona int not null,
enum('S','C','D','V','U')
); IdPersonaPapa int not null,
IdPersonaMama int not null,
create table if not exists profesores( Procedencia varchar(80),
IdPersona int, index(Idpersona),
cargo Varchar(50) not null, foreign key(IdPersona) references
Titulacion Varchar(50), personas(Idpersona),
Fechaingreso date, foreign key(IdPersonaPapa) references
index(Idpersona), personas(Idpersona),
foreign key(IdPersona) references foreign key(IdPersonaMama) references
personas(Idpersona) ); personas(Idpersona)
);
PROCESOS DE INGRESOS DE DATOS EN LAS TABLAS CREADAS:
MySQL al igual que otros gestores de base de datos admite la utilización del estándar SQL,
permitiendo el ingreso de datos de forma individual o colectiva, para el ejemplo se ingresarán datos
en ambos casos:
INSERT INTO personas (ApellidoPaterno, ApellidoMaterno, Nombres, Direccion, telefono, sexo,

FechaNacimiento, EstadoCivil)
VALUES ('Demera', 'Ureta', 'Gabriel', 'Cdla. Parque Forestal', '052123456','M','1974-03-18','C');

VALUES ('Montero', 'Zambrano','Paola', 'Cdla. Parque Forestal', '052123456','F','1979-04-23','C');


VALUES ('Espinoza','Alcívar', 'Elsa Argentina','Mejia', '052636111','F','1978/10/20','C');
La posibilidad de ingresar datos de forma colectiva un poco más cómoda y aplica el mismo principio:
FechaNacimiento, EstadoCivil) VALUES
('Hidalgo', 'Villamar','Luis Ernesto','Limón', '052580113','M','1977/08/25','C'),
('Aveiga', 'Zambrano','Enma', 'Montecristi', '052636222','F','1974/06/18','C'),
('Zambrano','Franco', 'Luis Felipe','García Moreno y sucre','052632333','M','1976/04/10','C'),
('López', 'Intriago','Blanca', 'Primero de Mayo', '052636444','F','1972/02/16','C'),
('Zedeño', 'Franco', 'Nora Alice', 'Morales y Rocafuerte', '052630555','F','1970/05/18','C'),
('Panta', 'Chica', 'José Vicente','Pedro Gual y morales','052580666','M','1972/10/12','C'),
('Ronquillo','Delgado','Ramón ','Av.Manabí,los Mangos ','052636777','M','1974/12/30','C'),
('Vaca', 'Arteaga', 'Víctor Hugo','Av. Ajuela y morales', '052580888','M','1976/10/10','C'),
('Salazar', 'Montesinos','Claudia', 'Parroq. San Pablo', '052580999','F','1979/09/08','C'),
('Moncayo', 'Hidalgo', 'Flora', 'Cdla. Los tamarindos', '052636505','F','1979/07/28','C'),
('Garcés', 'Jorge', 'Humberto', 'Cdla. Los Bosques', '052580123','M','1980/02/20','C');
TAREA 4: Elabore el diseño de una base de datos que permita registrar solo la venta de productos
informáticos, considere que se puede vender un disco duro de forma independiente así como parte
de un computador de escritorio, además, una promoción puede incluir la computadora de escritorio
y una impresora, entre otros, la presentación de la tarea debe incluir el diseño, la base de datos
física y los datos a ingresar de forma similar al ingreso colectivo.
PROCESOS DE EXTRACCIÓN DE DATOS EN LAS TABLAS CREADAS:
Los datos registrados pueden ser extraídos de la tabla mediante el uso de la instrucción SELECT , por
ejemplo, si se necesita el listado se todas las personas con todos sus datos podríamos hacerlo de la
siguiente forma:
SELECT IdPersona, ApellidoPaterno, ApellidoMaterno, Nombres, Direccion, telefono, sexo,
FechaNacimiento, EstadoCivil FROM personas;
Otra forma de mostrar el listado de todos los campos y obtener el mismo resultado es mediante el
uso del asterisco (*), por ejemplo:
SELECT * FROM personas;
Cuando se desean datos específicos, usted puede utilizar los que desee de la lista de campos, por
ejemplo, listar los apellidos, nombres, direcciones y fechas de nacimiento de todos los ingresados:
SELECT ApellidoPaterno, ApellidoMaterno, Nombres, Direccion, FechaNacimiento FROM personas;
Sí lo solicitado incluye una condición, por ejemplo, que solo sea para los de sexo femenino, se debe
incluir la cláusula WHERE que permite agregar condiciones de clasificación de datos, por ejemplo:
SELECT ApellidoPaterno, ApellidoMaterno, Nombres, Direccion, FechaNacimiento
FROM personas
WHERE sexo=’f’;
Si necesitamos mostrar la lista, solo de varones casados, quedaría así:

SELECT ApellidoPaterno, ApellidoMaterno, Nombres, Direccion, FechaNacimiento
FROM personas WHERE sexo=’m’ and EstadoCivil=’c’;

Se puede utilizar condiciones complejas, por ejemplo, sí se necesita la lista de personas mayores de
30 años de edad, entonces debería utilizar como referencia la fecha de hoy, asumamos que hoy es
18 de agosto de 2014; para resolver esta necesidad aplicaremos aritmética, es decir restamos 30
años a 2014 y nos quedaría 1984/09/18 (El formato natural de la fecha en MySQL es año/mes/día),
así que la instrucción quedaría:
SELECT ApellidoPaterno, ApellidoMaterno, Nombres, telefono, sexo, FechaNacimiento
FROM personas
WHERE FechaNacimiento <’1984/09/18’;
Podemos cambiar los formatos de salida que se utilizan para fecha en MySQL, por ejemplo,
mostraremos unidos los apellidos y el nombre, fecha de nacimiento con el formato día mes y año, y
sexo mostrará masculino o femenino:
SELECT concat(personas.ApellidoPaterno, ' ',personas.ApellidoMaterno ,' ',personas.Nombres) As
Estudiante, if(sexo='F','Femenino','Masculino') As Sexo, date_format(FechaNacimiento,’%d/%m/%Y’)
FROM personas;
Sí se necesita ver las edades de todas las personas utilizaremos la función TIMESTAMPDIFF que
devuelve la diferencia en años entre dos fechas, la cláusula CURRENT_DATE devuelve la fecha actual
que registra el servidor:
SELECT concat(personas.ApellidoPaterno,' ',personas.ApellidoMaterno,' ',personas.Nombres) As
Nombre, TIMESTAMPDIFF(YEAR,fechanacimiento,CURRENT_DATE) as edad FROM personas;
Sí necesitamos la lista ordenada por apellido paterno de forma ascendente o descendente se

utilizaría:
FROM personas ORDER BY ApellidoPaterno;

FROM personas ORDER BY ApellidoPaterno DESC;
Por defecto ordena ascendentemente, o si prefiere puede utilizar la instrucción ASC; también
puede incluir sub órdenes agregando una lista separada por comas, por ejemplo:
FROM personas ORDER BY ApellidoPaterno ASC, ApellidoMaterno DESC;
Asumiendo que necesitamos las tres personas que tengan más edad podríamos utilizar:
SELECT ApellidoPaterno, ApellidoMaterno, Nombres, sexo, FechaNacimiento
FROM personas ORDER BY FechaNacimiento ASC LIMIT 3;
Para obtener un listado de años de nacimiento sin que se repitan tendríamos que realizar lo
siguiente:
SELECT DISTINCT YEAR(FechaNacimiento) AS anio
FROM personas ORDER BY anio;
A menudo el diseño de las tablas incluye columnas que tienen tipos de datos de cadenas de
caracteres, y se necesita buscar datos que cumplan ciertos modelos de palabras. Esto se realiza a
través de un nuevo tipo de condición: Nombre_de_columna LIKE cadena_de_caracteres.
Con LIKE puede usar los siguientes dos caracteres comodines en el patrón o modelamiento:

CARÁCTER DESCRICIÓN
% Coincidencia de cualquier número de caracteres, incluso cero caracteres
_ Coincide exactamente un carácter
Para aplicar modelos de cómo utilizar esta herramienta, considere los siguientes ejemplos:
 Para listar todas las personas cuyo nombre empieza con la letra E
FROM personas
WHERE Nombres LIKE ‘E%’;
 Para listar todas las personas cuya segunda letra del apellido paterno es E
FROM personas
WHERE ApellidoPaterno LIKE ‘_E%’;
 Para listar todas las personas cuyo apellido paterno o materno es Zambrano
SELECT ApellidoPaterno, ApellidoMaterno, Nombres
FROM personas
WHERE concat(ApellidoPaterno, ' ', ApellidoMaterno ,' ', Nombres) LIKE ‘%Zambrano%’;
Otra posibilidad de obtener el mismo resultado anterior y aplicar la unión de varios select, es:
(SELECT ApellidoPaterno, ApellidoMaterno, Nombres FROM personas WHERE ApellidoPaterno=
‘Zambrano’)
UNION ALL
(SELECT ApellidoPaterno, ApellidoMaterno, Nombres FROM personas WHERE ApellidoMaterno=
‘Zambrano’);
 Si se necesita listar todos las personas cuyo apellido paterno no empiece con Z entonces
quedaría así:
FROM personas
WHERE ApellidoPaterno NOT LIKE ‘Z%’;
Para testear instancias literales en que la palabra incluya un carácter comodín, anteponga el
carácter con el carácter de escape. Si no especifica el carácter ESCAPE, se asume '\' .
CADENA DESCRICIÓN
\% Coincide un carácter '%'
\_ Coincide un carácter '_'
Si desea filtrar registros utilizando una lista de valores o palabras, puede hacer uso de la cláusula IN,
por ejemplo asuma que se desea ver la lista de personas cuyo apellido paterno es VACA, PANTA y
SALAZAR, se tendrá que hacer cualquiera de las siguientes posibilidades:
SELECT ApellidoPaterno, ApellidoMaterno, Nombres, sexo, direccion
FROM personas
WHERE ApellidoPaterno IN (‘Vaca’, ‘Panta’ , ‘Salazar’);

FROM personas
WHERE ApellidoPaterno=‘Vaca’ OR ApellidoPaterno=‘Panta’ OR ApellidoPaterno=‘Salazar’;

Considerando que desea hacer lo contrario, es decir que desea mostrar todas las personas, excepto
los descritos en el ejercicio anterior, se tendría que hacer:
FROM personas
WHERE ApellidoPaterno NOT IN (‘Vaca’, ‘Panta’ , ‘Salazar’);
El estándar SQL incluye funciones que permiten obtener resultado de un grupo de registros o de su
totalidad de registros, las funciones principales de cálculo de registros son: COUNT(), SUM(), AVG(),
MAX(), NIM(), entre otros; es importante destacar que cuando se aplica estas funciones, el
resultado en un solo registro.
Para aplicar su utilización, ejemplificamos los siguientes ejercicios:
 Sí se desea conocer cuántas personas tiene registrada la tabla personas se aplica lo siguiente.
SELECT count(ApellidoPaterno) As Total_de_Personas
FROM personas;
 Para ver el promedio de edades de todas las personas registradas se aplica.

SELECT AVG(TIMESTAMPDIFF(YEAR,fechanacimiento,CURRENT_DATE)) AS Promedio_Edades
FROM personas;
Existe la posibilidad de utilizar agrupamientos para que puedan existir varios totales dependiendo
de las necesidades de agrupar, para esto se utiliza la cláusula GROUP BY
 Para conocer cuántas personas nacieron por año de las que se encuentran registradas en
nuestra tabla podríamos realizar lo siguiente:
SELECT YEAR(FechaNacimiento), COUNT(YEAR(FechaNacimiento)) AS N_Personas_Nacidas
FROM Personas
GROUP BY YEAR(FechaNacimiento)
ORDER BY COUNT(YEAR(FechaNacimiento)) ;
 Si se necesita conocer el número de persona clasificados por sexo:

SELECT IF(Sexo='F','FEMENINO','MASCULINO') As Sexo, count(*) As Total_de_Personas
FROM personas
GROUP BY Sexo;
TAREA 5: Considerando el diseño del deber anterior, plantear 5 propuestas de clasificación de

datos con sus respectivos resultados, justifique cada propuesta.
CREACIÓN DE SUBCONSULTAS
Una sub consulta, es una sentencia SELECT que se ejecuta dentro de otra sentencia SELECT, que
para el caso se llamará consulta principal. Las sub consultas pueden ubicarse en la lista de
selección, dentro de la cláusula WHERE o dentro de la cláusula HAVING en la consulta principal.
Una sub consulta tiene la misma sintaxis que una sentencia SELECT normal, exceptuando que
aparece encerrada entre paréntesis, ésta no puede contener la cláusula ORDER BY, ni puede ser la
UNION de varias sentencias SELECT, además tiene algunas restricciones en cuanto al número de
columnas según el lugar donde aparece en la consulta principal.

Cuando se ejecuta una consulta que contiene una sub consulta, la sub consulta se ejecuta por cada
fila de la consulta principal. Se aconseja no utilizar campos calculados en las sub consultas, ya que
al ejecutarse fila a fila en la consulta principal produce retardo en la consulta.
Las consultas principales complejas que utilizan sub consultas suelen ser más fáciles de interpretar
por parte del usuario. Para realizar las siguientes prácticas, debe agregar más registros a las tablas
“Personas” y la tabla “Profesores”:
INSERT INTO Personas (ApellidoPaterno, ApellidoMaterno, Nombres, Direccion, telefono, sexo,
FechaNacimiento, EstadoCivil) VALUES
('Falcones','Canchingre','Ángela', 'Cdla. Los tamarindos', '052636456','F','1982/06/18','C'),
('Mora', 'Hidalgo', 'Octavio', 'Cdla. Ceibos del Norte','052360789','M','1970/05/08','C'),
('Delgado', 'Ramirez', 'Maricela', 'Cdla. Ceibos del Norte','054511133','F','1996/08/12','C'),
('Zambrano','Delgado', 'Javier', 'Cdla. Los Bosques', '052456123','M','1984-05-28','D'),
('Cardenas','Flores', 'Ana María', 'Eloy Alfaro y Plaza', '052100456','F','1991-03-18','D'),
('Basurto', 'Cedeño', 'Dolores', 'Cdla. Los Mangos', '052390987','F','1971/04/01','C'),
('Zambrano','López', 'José', 'parroq. San Placido', '052111654','M','1973/03/30','C'),
('Montesdeoca','Ureta','Elena ', 'Cdla. Forestal', '052222321','F','1974/01/25','C'),
('Farías', 'Salazar', 'Joel', 'Cdla. Terra Nostra', '052333254','M','1979/08/13','C'),
('Delgado', 'Manuel', 'Benedicto', 'Cdla. Los Bosques', '052444157','M','1979/09/23','C'),
('Navarrete','Ormaza', 'Yolanda', 'Cdla. Los tamarindos', '052534876','F','1981/01/10','C'),
('Giler', 'Mejía', 'Sócrates', 'Cdla. Ceibos del Norte','052778654','M','1985/03/18','C'),
('Mendieta','Vera', 'Juan Carlos','No Registrada', '052580505','M','1974/05/18','C'),
('Briónes', 'Zambrano','Gema', '25 de Diciembre', '052654987','F','1980/04/14','S'),
('Moya', 'Loor', 'Fernando', 'Morales', '052654987','M','1982/09/28','S'),
('Arias', 'De la Cruz','Ivan', 'Ramos y Duarte', '321654987','M','1990/08/25','V'),
('Andrade', 'Castro', 'Viviana ', 'San Placido', '052222233','F','2000/03/01','S'),
('Benitez', 'Sabando', 'Carmen', 'Calderon', '053333233','F','2001/06/30','S'),
('Burbano', 'Vera', 'José ', 'Rio Chico', '054444233','M','1995/02/17','S'),
('Zambrano','Cardenas', 'María José','Cdla. Bosques', '054561233','F','1999/06/10','S'),
('Zambrano','Cardenas','Eduardo', 'Rio Chico', '051111233','M','1995/03/01','S'),
('Zambrano','Falcones','Paola', 'Los tamarindos', '054871233','F','2000/03/18','S'),
('Demera', 'Montero', 'Alejandro', ' Cdla Parque Forestal','055551233','M','2001/01/20','S'),
('Mora', 'Delgado', 'Miguel Ángel','18 de octubre', '056666233','M','2002/03/15','S'),
('Zambrano','Bazurto', 'Leonardo', 'Los Mangos', '057771233','M','2000/08/11','S'),
('Zambrano','Bazurto', 'Enrique ', 'Los Tamarindos', '058888233','M','2002/11/11','S'),
('Farías', 'Montesdeoca','Francisco','Los Bosques', '059999233','M','1996/03/19','S'),
('Delgado','Navarrete','Carlos Luis','San Placido', '050001233','M','2001/12/31','S'),
('Giler', 'Briones', 'LilY Anabel', 'Cdla Forestal', '051112222','F','1990/03/21','S'),
('Mendieta','Andrade', 'Marcos', 'Cdla Primero de Mayo','051114444','M','1993/10/10','S'),
('Moya', 'Aveiga', 'Antonio', 'Parroquia Calderon', '051115555','M','2000/05/25','S'),
('Arias', 'Benitez', 'John Jairo', 'Vía a Rio Chico', '051116666','M','2002/07/30','S'),
('Burbano', 'Moncayo', 'Pedro Andrés','Floron 1', '051117777','M','1998/01/17','S'),
('Demera', 'Montero','Ma Gabriela','Cdla Parque Forestal','051118888','F','1995/05/09','S'),
('Mora', 'Delgado', 'Virginia Yessenia','Parr. Rio Chico','051119999','F','2001/06/04','S'),
('Zambrano','Falcones','José Daniel','San Alejo', '051111000','M','1992/07/15','S'),
('Moya', 'Aveiga', 'David Fabian','18 de octubre', '051111545','M','2000/09/21','S'),
('Giler', 'Briones', 'Fabricio', 'San Placido', '051111129','M','1994/11/12','S'),
('Mendieta','Andrade','Lourdes', 'Km1 vía a Rocafuerte', '051119876','F','2002/11/03','S'),
('Farías', 'Montesdeoca', 'Junior José', 'Los Angeles', '051115433','M','1998/12/18','S');
INSERT INTO Profesores (IdPersona, cargo, Titulacion, Fechaingreso)

VALUES (1, 'Profesor', 'Ingeniero en Sistemas', '2005-10-23'),
(2, 'Inspector', 'Lcda. en Educación básica', '2005-10-23'),

(3, 'Profesor', 'Lcda. En Literatura', '2002/01/10'),

(4, 'Profesor', 'Ingeniero Industrial', '2002/05/15'),
(5, 'Profesor', 'Lcda. En Cultura Física', '2000/05/20'),
(6, 'Profesor', 'Lcdo. En Historia y Geografía','2000/04/10'),
(7, 'Profesor', 'Economista', '2001/09/08'),
(8, 'Profesor', 'Lcda. Ciencias Matemáticas', '2001/04/18'),
(9, 'Profesor', 'Lcdo. En Idiomas', '2003/08/29'),
(10,'Profesor', 'Lcdo. En Psicología Clínica', '2000/05/29'),
(11,'Profesor', 'Lcdo. En Laboratorio Químico', '2003/04/10'),
(12,'Rector', 'Lcda. En Ciencias Matemáticas','1999/03/10'),
(13,'Profesor', 'Lcda. En Educación Básica', '1999/10/15'),
(14,'Vicerector','ingeniero Civil', '1999/07/25');
INSERT INTO padres(IdPersona,cargasfamiliares,TelefonoTrabajo,DireccionTrabajo,ocupacion)

VALUES (1, 2,'052000111','Av. Urbina y Che Guevara', 'Profesor'),
(2, 1,'052345678','Alajuela y Quito', 'Profesora'),
(16,2,'052176892','Manta', 'Abogado'),
(17,3,'052987654','Av. Manabí y América', 'Comerciante'),
(18,2,'052670158','Charapotó', 'Agricultor'),
(19,4,'052182637','Km 1 Vía a Manta', 'Secretaria'),
(6, 2,'052123123','Alajuela y Quito', 'Profesor'),
(15,2,'052123321','Morales y Rocafuerte', 'Diseñadora de carteles'),
(20,3,'052987654','América y Urbina', 'Foto Copiador'),
(21,3,'052987654','América y Urbina', 'Foto Copiador'),
(22,4,'', 'Cdla. Parque Forestal', 'Ama de Casa'),
(23,4,'', 'Los Almendros', 'Jardinero'),
(24,2,'052111999','Km1 via a crucita', 'Maquinista'),
(25,2,'052222333','Km1 via a crucita', 'Policia'),
(26,3,'052098765','Coop. Portoviejo', 'Chofer'),
(28,3,'052654876','Via a Crucita altura de gasolinera Univ.','Comerciante'),
(27,2,'', 'Manta', 'Capitan de Barco'),
(31,2,'052564876','San Placido', 'Ama de Casa'),
(29,1,'', 'Ciudad de Portoviejo', 'Taxista'),
(5, 1,'052345678','Alajuela y Quito', 'Profesora'),
(30,3,'052630123','Av. Universitaria y Che Guevara','Ingeniero Civil'),
(32,3,'052987396','18 de Octubre y Pedro Gual', 'Recepcionista'),
(33,2,'052198823','América y Urbina N1432', 'Electricista'),
(13,2,'052345678','Alajuela y Quito', 'Profesora');
INSERT INTO Estudiante(IdPersona,IdPersonaPapa,IdPersonaMama,Procedencia)

VALUES (37,1,2,'Escuela 12 de Marzo'),
(50,6,15,'Unidad Educativa Arco Iris'),
(49,16,17,'Escuela 12 de Marzo'),
(35,18,19,'Unidad Educativa Manta'),
(39,21,20,'Escuela Naval'),
(42,24,25,'Escuela Reales Tamarindos'),

(48,1,2,'Escuela 12 de Marzo');
Para probar el uso de sub consultas, se desarrollaran ejercicios modelos que le permitirán conocer
las diferentes posibilidades de uso:
 Para mostrar el listado de personas que son autoridades en la institución se lo realizaría así:
FROM personas
WHERE IdPersona IN (SELECT IdPersona FROM Profesores WHERE cargo <>’Profesor’);
Es importante destacar que las columnas utilizadas en la sub consulta no se muestran en la

consulta principal
 Para mostrar el nombre y apellidos del Rector de la institución se lo realizaría así:

FROM personas
WHERE IdPersona = (SELECT IdPersona FROM Profesores WHERE cargo=’Rector’);
 Para mostrar lo nombres y apellidos de los profesores que son padres de familia en la institución
se lo realizaría así:
FROM personas
WHERE IdPersona IN (SELECT IdPersona FROM Padres WHERE ocupacion like ’Profe%’);
 Si necesita mostrar la lista de estudiantes cuyas madres sean profesoras de la institución

quedaría así:
FROM personas
WHERE IdPersona IN (SELECT IdPersona FROM Estudiante WHERE IdPersonaMama IN (SELECT
idpersona FROM Profesores)) ORDER BY ApellidoPaterno;
Las sub consultas permiten comparar, desde la consulta principal los datos extraídos desde la
misma u otras tablas, pero no se pueden mostrar los campos de las sub consulta con los campos de
la consulta principal.
TAREA 6: Considerando el diseño del deber anterior en la que se planteaban 5 propuestas de

clasificación de datos, elabore 5 nuevas propuestas considerando el uso de sub consultas, justifique
cada propuesta.
CREACIÓN DE CONSULTAS MULTI-TABLAS

Hasta ahora todas las consultas que se han usado ejemplifican el mostrar datos de sólo una tabla,
pero también es posible crear consultas usando y mostrando las columnas de varias tablas en la
misma sentencia SELECT.

El uso de varias tablas en una misma consulta, es un proceso que permite ejecutar dos tipos de
operaciones de álgebra relacional: el producto cartesiano y la composición.
PRODUCTO CARTESIANO.- Este es un operador binario, se aplica a dos relaciones y el resultado es

otra relación. El resultado es una relación que contendrá todas las combinaciones de los registros
de los dos operandos.
Para entender esto analicemos lo siguiente: si partimos de dos relaciones, R y S, cuyos grados
(Numero de columnas) son n y m, y cuyas cardinalidades (número de registros) a y b, la relación
producto tendrá todos los atributos presentes en ambas relaciones, por lo tanto, el grado será n+m.
Además la cardinalidad será el producto de a y b.
Para ejemplificar el análisis, se usará dos tablas inventadas para el efecto:

tabla1(id, nombre, apellido)
tabla2(id, número)
tabla1
id nombre apellido
15 Fulginio Liepez
26 Cascanio Suanchiez
tabla2
id número
15 12345678
26 21222112
15 66525425
El resultado del producto cartesiano de tabla1 y tabla2 es: tabla1 x tabla2

id nombre apellido id número
15 Fulginio Liepez 15 12345678
26 Cascanio Suanchiez 15 12345678
Podemos ver que el grado resultante es 3+2=5, y la cardinalidad 2*3 = 6.

COMPOSICIÓN (JOIN).- Una composición (Join en inglés) es una restricción del producto cartesiano,
en la relación de salida, sólo incluyen los registros que cumplen una determinada condición.
La condición que se utiliza frecuentemente es la igualdad entre dos atributos, considerando uno de
cada tabla. La sintaxis sería:
<relación1> [<condición>] <relación2>
Considerando el ejemplo anterior. Se partirá de dos relaciones:
tabla1(id, nombre, apellido)
tabla2(id, número)
tabla1
id nombre apellido
15 Fulginio Liepez
26 Cascanio Suanchiez
tabla2
id número

15 12345678
26 21222112
15 66525425
La composición de estas dos tablas, para una condición en que 'id' sea igual en ambas sería:
tabla1[tabla1.id = tabla2.id]tabla2
id nombre apellido t2.id número
Para continuar con la ejemplificación de consultas multi-tablas mediante el uso de PRODUCTO

CARTESIANO y COMPOSICIONES, se crearán otras entidades como Matriculación, Periodos lectivos,
Especialidades, Cursos y Paralelos a nuestra base de datos UNIDAD como se muestra a
continuación:
CREATE TABLE if not exists PeriodosLectivos(

IdPeriodoLectivo int primary key auto_increment,
FechaInicio date,
FechaFinal date,
Nombre varchar(30)
);
CREATE TABLE if not exists Especialidades(
IdEspecialidad int primary key auto_increment,
NombreEspecialidad varchar(50)
);
CREATE TABLE if not exists Cursos(
IdCurso int primary key auto_increment,
Curso varchar(30)
);
CREATE TABLE if not exists Paralelos(
IdParalelo int primary key auto_increment,
Paralelo varchar(30)
);

CREATE TABLE if not exists Matriculas(

IdMatricula int primary key auto_increment,
IdPersonaEstudiante int not null,
IdPeriodoLectivo int not null,
IdEspecialidad int not null,
IdCurso int not null,
IdParalelo int not null,
IdPersonaRepresentante int not null,
Folder varchar(80),
index(IdPersonaEstudiante),
foreign key(IdPersonaEstudiante) references personas(Idpersona),
foreign key(IdPeriodoLectivo) references periodosLectivos(IdperiodoLectivo),
foreign key(IdEspecialidad) references Especialidades(IdEspecialidad),
foreign key(IdCurso) references Cursos(IdCurso),
foreign key(IdParalelo) references paralelos(Idparalelo),
foreign key(IdPersonaRepresentante) references personas(IdPersona)
);
Registre los siguientes datos a las nuevas entidades:
INSERT INTO PeriodosLectivos(FechaInicio,FechaFinal,Nombre)
VALUES ('2012-03-15','2013-02-15','PERIODO 2012 - 2013'),
('2013-03-15','2014-02-15','PERIODO 2013 - 2014');
INSERT INTO Especialidades(NombreEspecialidad)
VALUES ('Educacion Básica'),
('Bachillerato en Ciencias'),
('Bachillerato técnico');
INSERT INTO Cursos(Curso) VALUES
('Primero'), ('Segundo'), ('Tercero'), ('Cuarto'), ('Quinto'), ('Sexto'), ('Septimo');
INSERT INTO Paralelos(Paralelo) VALUES ('A'), ('B'), ('C'), ('D');
INSERT INTO Matriculas (IdPersonaEstudiante, IdPeriodoLectivo, IdEspecialidad, IdCurso, IdParalelo,

IdPersonaRepresentante, Folder) VALUES
(46,2,1,7,1,30,'Archivador A 25'),
(47,2,1,7,1,33,'Archivador A 26'),
(42,2,1,7,1,24,'Archivador A 25'),
(37,2,1,7,1,1, 'Archivador A 26'),
(48,2,1,6,1,2 ,'Archivador A 27'),
(41,2,1,7,1,22,'Archivador A 27'),
(54,2,1,6,1,23,'Archivador A 28'),
(43,2,1,7,1,26,'Archivador A 28'),
(52,2,1,6,1,26,'Archivador A 29'),
(44,2,1,7,1,27,'Archivador A 29'),
(53,2,1,6,1,27,'Archivador A 30'),
(38,2,1,7,1,16,'Archivador A 30'),
(49,2,1,7,1,16,'Archivador A 31'),
(45,2,1,6,1,29,'Archivador A 31'),
(51,2,1,6,1,29,'Archivador A 32'),
(35,2,1,6,1,19,'Archivador A 32'),
(40,2,1,6,1,20,'Archivador A 33'),
(39,2,1,7,1,20,'Archivador A 33'),
(36,2,1,6,1,15,'Archivador A 34'),
(34,2,1,7,1,19,'Archivador A 34');

EJEMPLOS CON PRODUCTO CARTESIANO
Sí Aplicamos producto cartesiano a las tablas cursos y paralelos de nuestra base de datos la
instrucción sería:
SELECT * FROM Cursos, paralelos;
El resultado sería, por cada registro de la tabla cursos se combinan con todos los registros de la
tabla paralelos, el ejemplo resultaría si se necesitara todas las combinaciones posibles entre dos
tablas, pero es necesario utilizar condiciones para ciertas necesidades de filtración. Si se necesitara
conocer la lista de profesores con sus datos personales, se aplicaría:
SELECT concat(ApellidoPaterno,’ ‘, ApellidoMaterno,’ ‘,Nombres) AS Personas, cargo, titulacion
FROM Personas, Profesores
WHERE Personas.IdPersona=Profesores.IdPersona;
Aplicando producto cartesiano con tres tablas, se mostrará el listado de estudiantes matriculados
con sus respectivos representantes:
SELECT concat(personas.ApellidoPaterno, ‘ ‘,
personas.ApellidoMaterno, ‘ ‘, personas.Nombres) As
Estudiantes, Matriculas.IdMatricula As Matricula,
concat(personas_1.ApellidoPaterno, ‘ ‘,
personas_1.ApellidoMaterno,’ ‘, personas_1.Nombres)
As Representante
FROM Personas AS personas_1, Personas, Matriculas
WHERE
personas.IdPersona = matriculas.IdPersonaEstudiante
AND personas_1.IdPersona =
matriculas.IdPersonaRepresentante;
Cuando se utiliza dos veces la misma tabla en una consulta, es obligatorio definir al menos un alias
para diferenciarlas entre sí.
Para aplicar producto cartesiano con cuatro tablas, mostraremos el listado de estudiantes
matriculados de sexto año de básica con sus respectivos representantes:

SELECT concat(personas.ApellidoPaterno, ‘ ‘, personas.ApellidoMaterno, ‘ ‘,

personas.Nombres) As Estudiantes, Matriculas.IdMatricula As Matricula,
concat(personas_1.ApellidoPaterno, ‘ ‘, personas_1.ApellidoMaterno,’ ‘,
personas_1.Nombres) As Representante
FROM Personas AS personas_1, Personas, Matriculas, Cursos
WHERE
personas.IdPersona = matriculas.IdPersonaEstudiante AND personas_1.IdPersona =
matriculas.IdPersonaRepresentante AND Cursos.IdCurso = matriculas.IdCurso AND
Cursos.Curso='Sexto';
El INNER JOIN es una de varias opciones de composición de tablas, permite emparejar filas de
distintas tablas de forma más eficiente que con el producto cartesiano cuando una de las columnas
de emparejamiento está indexada. Ya que en vez de hacer el producto cartesiano completo y luego
seleccionar la filas que cumplen la condición de emparejamiento, para cada fila de una de las tablas
busca directamente en la otra tabla las filas que cumplen la condición, con lo cual se emparejan sólo
las filas que luego aparecen en el resultado. La sintaxis es la siguiente:
tabla1 y tabla2 son especificaciones de tablas o entidades de la base de datos, esto incluye tablas
con alias y vistas, que contienen relación entre sí. Col1 y col2 son las columnas o campos de
emparejamiento.
Observe que dentro de la cláusula ON los nombres de las columnas deben ser nombres cualificados
lo que significa que si tienen el mismo nombre se le debe anteponer el nombre de la tabla y un
punto de separación.
Las columnas de emparejamiento deben contener la misma clase de datos, las dos de tipo texto, de
tipo fecha etc... Los campos numéricos deben ser de tipos similares. Por ejemplo, se puede
combinar campos AutoNumérico y Long, puesto que son tipos similares, sin embargo, no se puede
combinar campos de tipo Simple y Doble; además las columnas no pueden ser de tipo Memo ni
OLE.
comp representa cualquier operador de comparación ( =, <, >, <=, >=, o <> ) y se utiliza para
establecer la condición de emparejamiento. Se pueden definir varias condiciones de
emparejamiento unidas por los operadores AND y OR poniendo cada condición entre paréntesis.
Por ejemplo: Si necesitamos ver el listado de profesores, tendríamos:

SELECT personas.ApellidoPaterno, personas.ApellidoMaterno, personas.Nombres, profesores.cargo,
profesores.Titulacion
FROM personas INNER JOIN profesores ON personas.IdPersona = profesores.IdPersona;
Se pueden combinar más de dos tablas, en este caso hay que sustituir en la sintaxis de la segunda
tabla por un INNER JOIN completo.

Por ejemplo, sí necesitamos el listado de todos los estudiantes matriculados con sus respectivos
representantes, tendríamos:
SELECT personas.ApellidoPaterno, personas.ApellidoMaterno, personas.Nombres,
matriculas.IdMatricula, personas_1.ApellidoPaterno, personas_1.ApellidoMaterno,
personas_1.Nombres, personas_1.Nombres
FROM personas AS personas_1 INNER JOIN (personas INNER JOIN matriculas ON personas.IdPersona
= matriculas.IdPersonaEstudiante) ON personas_1.IdPersona = matriculas.IdPersonaRepresentante;
Considerando el ejemplo desarrollado con producto cartesiano, sí necesitamos el listado de

estudiantes matriculados de sexto año de básica con sus respectivos representantes, tendríamos:
SELECT personas.ApellidoPaterno, personas.ApellidoMaterno, personas.Nombres,
matriculas.IdMatricula, personas_1.ApellidoPaterno, personas_1.ApellidoMaterno,
personas_1.Nombres, personas_1.Nombres, cursos.Curso
FROM cursos INNER JOIN (personas AS personas_1 INNER JOIN (personas INNER JOIN matriculas ON
personas.IdPersona = matriculas.IdPersonaEstudiante) ON personas_1.IdPersona =
matriculas.IdPersonaRepresentante) ON cursos.IdCurso = matriculas.IdCurso
WHERE cursos.Curso='Sexto';
TAREA 7: diseñe una base de datos que registre el arrendamiento y pago mensual del arriendo,
para un edificio que alquila cuartos y apartamentos, a estudiantes universitarios, una vez diseñada
la base de datos, proponga 5 consultas aplicando producto cartesiano y su similar en composición,
justifique cada propuesta.

VISTAS EN MySQL
Las vistas tienen la misma estructura que una tabla: filas y columnas. La única diferencia es que sólo
se almacena de ellas la definición, no los datos. Los datos que poseen son los que se recuperan
mediante la ejecución de una consulta, una vista se representa igual que una tabla, de hecho, si no
se sabe que se está trabajando con una vista, nada le haría suponer lo contrario. Al igual que
sucede con una tabla, se pueden insertar, actualizar, borrar y seleccionar datos en una vista.
Aunque su utilización en siempre la de seleccionar datos de una consulta, en algunas condiciones
existen restricciones para realizar el resto de las operaciones sobre vistas.
Una vista se especifica a través de una expresión de consulta (una sentencia SELECT) que la calcula y
que puede realizarse sobre una o más tablas. Sobre un conjunto de tablas relacionales se puede
trabajar con un número cualquiera de vistas.
La mayoría de los SGBD soportan la creación y manipulación de vistas, las vistas se crean cuando se
necesitan hacer varias sentencias para devolver una tabla final.
Para crear una vista se emplea la sentencia CREATE VIEW, que incluye una sub consulta
(subquery) para determinar los datos a ser mostrados a través de la vista la sintaxis es:
CREATE [OR REPLACE] [FORCE | NOFORCE] VIEW <vista>
[(<alias>[, <alias>] … )]
AS <subconsulta>
[WITH CHECK OPTION [CONSTRAINT <restricción>]]
[WITH READ ONLY [CONSTRAINT <restricción>]];
Dónde: OR REPLACE Se utiliza por si la vista ya estuviera creada anteriormente, en ese caso, la
sustituye por la nueva definición, por ejemplo si necesitamos crear una vista que muestra el listado
de profesores:
CREATE VIEW V_Lista_Profesores AS
SELECT ApellidoPaterno, ApellidoMaterno,Nombres, Titulacion
FROM profesores INNER JOIN personas ON profesores.IdPersona = personas.IdPersona
WHERE profesores.cargo Like 'prof%'
ORDER BY ApellidoPaterno;
Si necesita chequear la creación de la vista, utilice el comando (SHOW TABLES;), para verificar el
contenido de la vista, utilice: DESCRIBE V_lista_Profesores;
Para observar la codificación de la vista se utiliza: SHOW CREATE VIEW V_lista_Profesores;
Para ver la vista ejecutada utilice el comando: SELECT * FROM v_lista_profesores;
Asumiendo que la vista tiene fallas, lo más recomendable es volver a ejecutar la vista utilizando la
sintaxis OR REPLACE, por ejemplo:
CREATE OR REPLACE VIEW V_Lista_Profesores AS
SELECT ApellidoPaterno, ApellidoMaterno,Nombres, Titulacion
FROM profesores, personas
WHERE profesores.IdPersona = personas.IdPersona AND profesores.cargo Like 'prof%'
ORDER BY ApellidoPaterno;
Observe la codificación de la vista y verificará los cambios.

Indicaciones y restricciones de uso:

 La subconsulta puede contener una sentencia SELECT de sintaxis compleja, incluyendo
combinaciones (JOIN), agrupamientos (GROUP BY), y subconsultas internas.
 Pero en algunas versiones no puede incluir una cláusula ORDER BY. Si se desea ordenar, esto
deberá hacerse mediante una consulta posterior que utilice la vista.
Eliminando una vista

Es correcto que cuando ya no se va a emplear más una vista, ésta deba ser eliminada del esquema
de la base de datos mediante la siguiente orden:
DROP VIEW <vista>;
Dónde: <vista> Es el nombre de la vista, por ejemplo:

DROP VIEW EmpDepVentas;
Técnicamente una vista es definida como una tabla temporal, sí usted utiliza el comando “SHOW
TABLES;” podrá observarla como si se tratara de una tabla adicional, de hecho se puede aplicar
condiciones y relaciones sobre ellas.
Para entrar en detalle, el siguiente ejemplo crea una vista que muestra la lista de estudiantes por
cursos y paralelos:
CREATE VIEW V_Lista_Estudiantes AS
SELECT ApellidoPaterno, ApellidoMaterno, Nombres, Curso, Paralelo
FROM personas INNER JOIN (paralelos INNER JOIN (cursos INNER JOIN matriculas ON
cursos.IdCurso= matriculas.IdCurso)
ON paralelos.IdParalelo = matriculas.IdParalelo) ON personas.IdPersona =
matriculas.IdPersonaEstudiante
ORDER BY ApellidoPaterno, ApellidoMaterno;
Para aplicar una condición a la vista como si se tratara de una tabla se lo realiza de la siguiente
manera:
SELECT * FROM V_lista_Estudiantes WHERE curso='septimo' AND paralelo=’A’;
Es importante entender que los campos a utilizar en la comparación deben estar en el listado de la
consulta interna de la vista.
El siguiente ejemplo creará 2 vistas para ser utilizadas en una relación, el resultado consiste en
mostrar la lista de estudiantes cuyos padres sean profesores:
1. Se creará una vista para extraer el identificador del papá, los apellidos y nombres del
estudiante:
CREATE VIEW V_DatosEstudiantes AS
SELECT idpersonapapa, concat(apellidopaterno,' ',apellidomaterno,' ',nombres) AS Estudiante
FROM Estudiante, Personas
WHERE Personas.idpersona=Estudiante.idpersona;
2. Ésta otra vista extraerá el identificador del profesor, así como sus apellidos y nombres
CREATE VIEW V_DatosProfesores AS
SELECT personas.IdPersona, concat(ApellidoPaterno,’ ‘, ApellidoMaterno,’ ‘,Nombres) AS Profesor
FROM profesores, personas
WHERE profesores.IdPersona = personas.IdPersona AND profesores.cargo Like 'prof%';

3. La siguiente vista relacionará las dos vistas anteriores mediante el uso del identificador del
papá del estudiante y el identificador del profesor
CREATE VIEW V_ProfesoresHijos AS
SELECT profesor, estudiante
FROM V_DatosProfesores,V_DatosEstudiantes
WHERE idpersona=idpersonapapa;
Para probar el resultado se ejecuta un SELECT con la última vista de la siguiente forma:
SET @numero=0;
SELECT @numero:=@numero+1 AS Numero, V_profesoreshijos .* FROM V_profesoreshijos;
En el ejemplo se esta utilizando una variable de consola, se la reconoce porque se le

antepone el @, al ejecutar esta acción le mostrará numeradas las filas del resultado del
SELECT.
TAREA 8: diseñe una base de datos que registre el alquiler de motos y cuadrones para una pista de
carrera a campo traviesa, los valores de alquiler dependerán del tipo de vehículo y del tiempo
separado en horas, considere que existen clientes con preferencia de crédito, y que existen
vehículos que están en mantenimiento, considerando la base de datos proponga 5 vistas que
incluyan consultas con producto cartesiano o composición, justifique cada propuesta.

USUARIOS Y PRIVILEGIOS
Hasta ahora sólo se ha accedido mediante el usuario 'root', que es considerado como el súper
usuario o el administrador, y que dispone de todos los privilegios disponibles en MySQL.
Sin embargo, normalmente no será una buena práctica dejar que todos los usuarios con acceso al
servidor tengan todos los privilegios. Para conservar la integridad de los datos y de las estructuras
será conveniente que sólo algunos usuarios puedan realizar determinadas tareas, y que otras, que
requieren mayor conocimiento sobre las estructuras de bases de datos y tablas, sólo puedan
realizarse por un número limitado y controlado de usuarios.
Los conceptos de usuarios y privilegios están íntimamente relacionados. No se pueden crear

usuarios sin asignarle al mismo tiempo privilegios, de hecho, la necesidad de crear usuarios está
ligada a la necesidad de limitar las acciones que tales usuarios pueden llevar a cabo.
MySQL permite definir diferentes usuarios, y además, asignar a cada uno determinados privilegios
en distintos niveles o categorías de ellos.
NIVELES DE PRIVILEGIOS
En MySQL existen cinco niveles distintos de privilegios:
Globales: se aplican al conjunto de todas las bases de datos en un servidor, es el nivel más alto de
privilegio, en el sentido de que su ámbito es el más general.
Estos permisos se almacenan en la tabla mysql.user. GRANT ALL ON *.* y REVOKE ALL ON *.*
otorgan y quitan sólo permisos globales.
De base de datos: se refieren a bases de datos individuales, y por extensión, a todos los objetos que
contiene cada base de datos.
Estos permisos se almacenan en las tablas mysql.db y mysql.host. GRANT ALL ON nombre_bd.* y
REVOKE ALL ON nombre_bd.* otorgan y quitan sólo permisos de bases de datos.
De tabla: se aplican a tablas individuales, y por lo tanto, a todas las columnas de esas tabla.
Estos permisos se almacenan en la tabla mysql.tables_priv. GRANT ALL ON nombre_bd.nombre_tbl
y REVOKE ALL ON nombre_bd.nombre_tbl otorgan y quitan permisos sólo de tabla.
De columna: se aplican a una columna en una tabla concreta.
Estos permisos se almacenan en la tabla mysql.columns_priv . Usando REVOKE, debe especificar las
mismas columnas que se otorgaron los permisos.
De rutina: se aplican a los procedimientos almacenados. Aún no hemos visto nada sobre este tema,
pero en MySQL se pueden almacenar procedimientos consistentes en varias consultas SQL.
CREAR USUARIOS
Aunque en la versión 5.0.2 de MySQL existe una sentencia para crear usuarios llamada CREATE
USER, en versiones anteriores, se usa exclusivamente la sentencia GRANT para crearlos, pero en
general es preferible usar GRANT, ya que si se crea un usuario mediante CREATE USER,
posteriormente hay que usar una sentencia GRANT para concederle privilegios, usando GRANT
podemos crear un usuario y al mismo tiempo concederle también los privilegios que tendrá, la
sintaxis simplificada que se usa para GRANT, es:

GRANT tipo_privilegios [(lista_columnas)] [, tipo_privilegios [(lista_columnas)]] ...

ON
TO usuario [IDENTIFIED BY [PASSWORD] 'clave']
[, usuario [IDENTIFIED BY [PASSWORD] 'clave']] ...
La primera parte tipo_privilegios[(lista_columnas)] describe que se puede definir el tipo de

privilegio concedido para determinadas columnas o campos en una tabla. La segunda ON
{nombre_tabla | * | *.* | nombre_bd.*}, describe el conceder privilegios a niveles globales de la
base de datos o de las tablas.
Para crear un usuario sin privilegios usaremos la sentencia:

mysql> GRANT USAGE ON *.* TO anonimo IDENTIFIED BY 'clave';
Hay que tener en cuenta que la contraseña ‘clave’ se debe introducir entre comillas de forma
obligatoria, el usuario 'anonimo' podrá abrir una sesión MySQL, pero estará limitado al no poder ver
y explorar o gestionar los datos o su estructura, ya que no tiene privilegios, como ejemplo para
acceder al servidor utilizando éste usuario, se realiza lo siguiente:
%mysql -h localhost -u anonimo –p
MOSTRAR LOS PRIVILEGIOS DE UN USUARIO
Podemos ver qué privilegios se han concedido a un usuario mediante la sentencia SHOW GRANTS.
La salida de esta sentencia es una lista de sentencias GRANT que se deben ejecutar para conceder
los privilegios que tiene el usuario. Por ejemplo:
mysql> SHOW GRANTS FOR anonimo;
PARA CONCEDER PRIVILEGIOS
Para que un usuario pueda hacer algo más que consultar algunas variables del sistema debe tener
algún privilegio. Lo más simple es conceder el privilegio para seleccionar datos (SELECT) de una
tabla concreta; la misma sentencia GRANT se usa para añadir privilegios a un usuario existente,
esto se haría utilizando un usuario administrador con privilegios para crear usuarios de la siguiente
forma:
mysql> GRANT SELECT ON unidad.personas TO anonimo;
Esta sentencia concede al usuario 'anonimo' el privilegio de ejecutar sentencias SELECT sobre la
tabla 'Personas' de la base de datos 'Unidad', observe que no se agregó la clave de acceso, ya que
se creó la contraseña al crear el usuario sin privilegios, no hace falta ponerla, con poner los
privilegios basta.
Para practicar y verificar los privilegios asignados al usuario “anónimo”, abra una nueva sesión e
identifíquese como 'anonimo', una vez que accedió podrá ejecutar estas sentencias:
mysql> SHOW DATABASES;
mysql> USE Unidad;
mysql> SHOW TABLES;
mysql> SELECT * FROM personas;
Como se ve, para este usuario sólo existe la base de datos 'Unidad' y dentro de esta, la tabla
'Personas'. Además, podrá hacer consultas solo sobre esa tabla, pero no podrá añadir ni modificar
datos, ni por supuesto, crear o destruir tablas ni bases de datos.

Para conceder privilegios globales se usan comodines de la siguiente forma: ON *.*, esto indicará
que los privilegios se conceden en todas las tablas de todas las bases de datos.
Para conceder privilegios en bases de datos específicas se usa ON nombre_bd.*, indicando que los
privilegios se conceden sobre todas las tablas de la base de datos 'nombre_bd'.
Usando ON nombre_bd.nombre_tabla, concedemos privilegios de nivel de tablas para la tabla y

base de datos especificada.
En cuanto a los privilegios de columnas o campos, para concederlos se usa la sintaxis tipo_privilegio
(lista_de_columnas), [tipo_privilegio (lista_de_columnas)], para mayor detalle, considere la
siguiente forma:
GRANT privilegios(lista_de_columnas) ON nombre_bd.nombre_tabla TO 'usuario'@'localhost/ip'
IDENTIFIED BY 'clave';
El usuario “anonimo" utilizado para ejemplificar éste capítulo, ya cuenta con privilegios asignados
para extraer datos desde la tabla “Personas”, ahora para el siguiente ejemplo se le permitirá extraer
solo los nombres de los periodos lectivos, más no los otros datos de la misma tabla, para realizar
ésta práctica, los privilegios deben ser otorgados por el usuario administrador de la siguiente forma:
GRANT SELECT(nombre) ON Unidad.PeriodosLectivos TO a33nonimo;
Para probar los privilegios asignados se accederá al servidor con el usuario “anonimo” desde otra
ventana o sesión, para la práctica escriba los siguientes comandos:
mysql>SHOW DATABASES;
mysql>USE Unidad;
mysql>SHOW TABLES;
mysql>DESCRIBE PeriodosLectivos;
mysql>SELECT nombre FROM PeriodosLectivos;
Al aplicar los comandos notará que solo se le mostrará las tablas PERSONAS y PERIODOSLECTIVOS,
ya que sobre ellas se le han asignado privilegios, al aplicar el comando “DESCRIBE PeriodosLectivos;”
notará que solo le muestra el campo o columna “Nombre”, el resto le es oculto, sí usted intentara
utilizar el comando “SELECT * FROM PeriodosLectivos;” le mostrará un error porque ha intentado
evadir privilegios.
Aplicando otro ejemplo, en la sesión del administrador, ejecute la siguiente instrucción:

mysql>GRANT UPDATE(IdPersona, Direccion) ON Unidad.Personas TO 33anonimo;
Para probar el privilegio asignado, en la otra ventana o sesión, debe recordar que antes se le debe
asignar privilegio SELECT, de lo contrario no funcionará, escriba los siguientes comandos:
mysql>UPDATE Personas SET Direccion=’Edif. Santa Clara’ WHERE idpersona=1;
mysql>SELECT * FROM Personas WHERE idpersona=1;;
Como administrador también se puede cambiar el nombre del usuario mediante el comando
RENAME, esto no afectará los privilegios asignados, ejemplo:
RENAME USER anonimo TO anoni;
Los privilegios que se pueden conceder son: ALL que permite conceder todos los privilegios y los
detallados en el siguiente cuadro que se aplican de forma específica:

PRIVILEGIO COLUMNA CONTEXTO

CREATE Create_priv bases de datos, tablas, o índices
DROP Drop_priv bases de datos o tablas
GRANT OPTION Grant_priv bases de datos, tablas, o procedimientos
almacenados
REFERENCES References_priv bases de datos o tables
ALTER Alter_priv tablas
DELETE Delete_priv tablas
INDEX Index_priv tablas
INSERT Insert_priv tablas
SELECT Select_priv tablas
UPDATE Update_priv tablas
CREATE VIEW Create_view_priv vistas
SHOW VIEW Show_view_priv vistas
ALTER ROUTINE Alter_routine_priv procedimientos almacenados
CREATE ROUTINE Create_routine_priv procedimientos almacenados
EXECUTE Execute_priv procedimientos almacenados
FILE File_priv acceso a archivos en la máquina del servidor
CREATE TEMPORARY Create_tmp_table_priv administración del servidor
TABLES
LOCK TABLES Lock_tables_priv administración del servidor
CREATE USER Create_user_priv administración del servidor
PROCESS Process_priv administración del servidor
RELOAD Reload_priv administración del servidor
REPLICATION CLIENT Repl_client_priv administración del servidor
REPLICATION SLAVE Repl_slave_priv administración del servidor
SHOW DATABASES Show_db_priv administración del servidor
SHUTDOWN Shutdown_priv administración del servidor
SUPER Super_priv administración del servidor
Esta tabla ha sido tomada de la página oficial de mysql.
Se pueden conceder varios privilegios en una única sentencia. Por ejemplo:

GRANT SELECT, INSERT, UPDATE, DELETE, ALTER, CREATE, DROP ON Unidad.Profesores TO anonimo;
Para crear un usuario administrador, entre todos los privilegios debe tener el privilegio GRANT
OPTION, un ejemplo de cómo crearlo sería:
mysql > GRANT ALL PRIVILEGES ON *.* TO DBA2 IDENTIFIED BY '123' WITH GRANT OPTION;
Es importante que considere que este tipo de privilegio, solo es aconsejable para los
administradores, y no para un usuario sin responsabilidad administrativa.
Los usuarios creados hasta el momento, poseen privilegios implícitos de acceso local y remota, un
usuario de acceso local explicito sería:
mysql>GRANT ALL PRIVILEGES ON *.* TO 'usuario'@'localhost' IDENTIFIED BY '123' WITH GRANT
OPTION;
A veces es necesario utilizar el comando (FLUSH PRIVILEGES) para asegurarse de actualizar los
privilegios asignados en la base de datos administrativa de MySQL, su uso se simplifica de la
siguiente forma:
mysql> FLUSH PRIVILEGES;

VARIACIONES PARA ACCESOS REMOTOS AL SERVIDOR DE BASE DE DATOS
Como podemos ver por la salida de la sentencia SHOW GRANTS, el nombre de usuario no se limita a
un nombre simple, sino que tiene dos partes. La primera consiste en un nombre de usuario, en
nuestro ejemplo 'anonimo'. La segunda parte, que aparece separada de la primera por el carácter
'@' es un nombre de máquina (host). Este nombre puede ser bien el de una máquina, por ejemplo,
'localhost' para referirse al ordenador local, o cualquier otro nombre, o bien una IP.
La parte de la máquina es opcional, y si como en nuestro caso, no se pone, el usuario podrá

conectarse desde cualquier máquina. La salida de SHOW GRANTS lo indica usando el comodín '%'
para el nombre de la máquina.
Para conectarse a una determinada base de datos debe existir un usuario con privilegios de acceso
remoto, para conectarse al servidor de MySQL localmente se necesita la contraseña del usuario
"root" de MySQL.
Suponiendo que se desea permitir el acceso al usuario "Cajero1", a la base de datos "Unidad" desde
el host remoto con IP "192.168.1.101", utilizando la contraseña "cajero1234", se tendría que
realizar algo así:
mysql> GRANT ALL ON unidad.* TO 'cajero1'@'192.168.1.101' IDENTIFIED BY 'cajero1234';
Es posible verificar el acceso al servidor de MySQL que se encuentra en un Host con la IP

(192.168.1.1), desde el servidor remoto (192.168.1.101), para esto ejecute:
mysql -u cajero1 -h 192.168.1.1 -p
Aunque no es una práctica recomendable desde el punto de vista de la seguridad del servidor, Si se
desea que el usuario "cajero1" pueda acceder a la base de datos desde cualquier host, utilice:
mysql>GRANT ALL ON unidad.* TO 'cajero1'@'%' IDENTIFIED BY 'cajero1234';
Podría utilizar el formato (cajero1@'192.168.1.%') para que el acceso al servidor solo sea desde la
Red que tienen la misma IP del servidor. También puede hacer uso de (cajero1@'%.midominio.org')
para permitir el acceso desde un servidor WEB.
PARA REVOCAR PRIVILEGIOS
La revocación de privilegios no significa eliminación de usuario, para revocar privilegios se usa la

sentencia REVOKE, su sintaxis es la siguiente:
REVOKE tipo_privilegio [(lista_columnas)] [, tipo_privilegio [(lista_columna)]] ...
ON
FROM usuario [, usuario] ...
La sintaxis es similar a la de GRANT, por ejemplo, para revocar el privilegio SELECT del usuario
'anonimo', usaremos la sentencia:
mysql> REVOKE SELECT ON unidad.personas FROM anonimo;
Para quitar privilegios asignados a los campos, aplicamos lo siguiente:

mysql> REVOKE SELECT(nombre) ON Unidad.PeriodosLectivos FROM anonimo;
mysql> REVOKE UPDATE(IdPersona, Direccion) ON Unidad.Personas FROM 35anonimo;

Ahora se realizará una práctica que involucre la aplicabilidad de privilegios y su revoque parcial y
total de los mismos:
Se creara un usuario llamado “orion”, se le concederá los siguientes privilegios:
mysql> GRANT select, insert, update, delete, index, alter, create, drop ON unidad.* TO orion
IDENTIFIED BY '123';
mysql> SHOW GRANTS FOR orion;
Como una ejemplificación extrema, considere que el usuario “orion” ha incurrido en violar las
normas de restricciones y por lo tanto se le quitará algunos privilegios:
mysql> REVOKE alter, create, drop ON unidad.* FROM orion;
Si al final nos comunica el usuario “orion”que no quiere más ser usuario de nuestra base de datos,
entonces se pondrá revocar todos los privilegios:
mysql > REVOKE ALL ON unidad.* FROM orion;
Es importante recordar que la contraseña es opcional, si se la crear se puede escribir entre comillas
simples, o se puede usar la salida de la función PASSWORD() de forma literal para crearla y
encriptarla y evitar enviar la clave en texto legible.
Si al añadir privilegios se usa una clave diferente en la cláusula IDENTIFIED BY, sencillamente se
sustituye la contraseña por la nueva.
PARA BORRAR USUARIOS

Para eliminar usuarios se usa la sentencia DROP USER.
No se puede eliminar un usuario que tenga privilegios, por ejemplo:
mysql> DROP USER anonimo;
ERROR 1268 (HY000): Can't drop one or more of the requested users
Para eliminar el usuario primero hay que revocar todos sus privilegios:
mysql> DROP USER anonimo;
TAREA 9: Considerando la base de datos ejemplo “unidad”, planifique y cree usuarios con
privilegios para: docentes, estudiantes, secretarias, autoridades y padres de familia, asuma que
estos privilegios servirán para acceder a la base de datos mediante software aplicativo de escritorio
y WEB, justifique los privilegios y restricciones.

PROCEDIMIENTOS ALMACENADOS
Los procedimientos almacenados (stored procedure en inglés) y las funciones, son herramientas
disponibles desde la versión de MySQL 5.0; un procedimiento almacenado es un conjunto de
comandos SQL con propósito lógico, que pueden contenerse en el servidor de base de datos, esto le
permitirá reducir líneas de codificación en la interfaces de desarrollo de las aplicaciones que utilicen
la base de datos, reduciendo la transferencia de los comandos individuales SQL, a solo ejecutar
procedimientos almacenados.
Algunas situaciones en que los procedimientos almacenados pueden ser particularmente útiles es:
 Cuando múltiples aplicaciones “clientes” se escriben en distintos lenguajes o funcionan en

distintas plataformas o sobre distintas tecnologías, pero necesitan realizar la misma
operación sobre la base de datos.
 Cuando la seguridad es muy importante. Los bancos, por ejemplo, usan procedimientos
almacenados para todas las operaciones comunes. Esto proporciona un entorno seguro y
consistente, y los procedimientos pueden asegurar que cada operación se loguea o accede
apropiadamente. En tal entorno, las aplicaciones y los usuarios no obtendrían ningún acceso
directo a las tablas de la base de datos, sólo pueden ejecutar algunos procedimientos
almacenados.
Los procedimientos almacenados pueden mejorar el rendimiento transaccional de las gestiones de

datos, ya que se necesita enviar menos información entre el cliente y el servidor, es importante
destacar que éste intercambio aumenta la carga en el servidor de la base de datos, ya que la
mayoría del trabajo se realizará en la parte del servidor y no en el cliente.
Los procedimientos almacenados le permitirán tener bibliotecas o funciones en el servidor de base

de datos, ya que necesitará documentar las diferentes funcionalidades; esta característica es
compartida por los lenguajes de programación modernos, que permiten este diseño interno, por
ejemplo, usando clases. Usando estas características del lenguaje de programación en el cliente, es
beneficioso para el programador, incluso fuera del entorno de la base de datos. MySQL sigue la
sintaxis SQL:2003 para procedimientos almacenados, que también usa IBM con su sistema de
gestión de base de datos DB2. Los procedimientos y funciones almacenadas cumplen con el
siguiente formato:
CREATE PROCEDURE nombre_pa ([parametro[,...]])

[característica ...] cuerpo_de_la_rutina
CREATE FUNCTION number_pa ([parametro[,...]]) RETURNS tipo_de_dato_a_devolver

[característica ...] cuerpo_de_la_rutina
Parámetros a utilizar:
[ IN | OUT | INOUT ] nombre_de_parametro tipo_de_dato
Los procedimientos y las funciones almacenadas, poseen características notables de codificación y

su aplicabilidad y campo de acción de detallan a continuación en el siguiente cuadro:

PROCEDURE FUNCTION
Llamada Solo con CALL Posible en todas las instrucciones
SQL (SELECT, UPDATE, …)
Retorno Puede retornar uno o más Retorna un valor único de un tipo
SELECT determinado.
Parámetros Permite por valor y por Permite por valor y por
referencia(IN, OUT, INOUT) referencia(IN, OUT, INOUT)
Instrucciones permmitidas Todas las SQL Con limitaciones
Llamadas a otras funciones o Puede llamar a otros Solo puede llamar otras funciones
procedimientos procedimientos y/o funciones
El formato indica que la lista de parámetros entre paréntesis debe estar siempre presente. En caso
de no existir parámetros, se debe usar una lista de parámetros vacía (); cada parámetro es un
parámetro IN por defecto, que indica que el contenido de la variable solo es de entrada; para
especificar otro tipo de parámetro, use la palabra clave OUT que indica que el contenido de la
variable es retornado desde el procedimiento al lugar donde fue llamado, o INOUT que indica que
su contenido en de ingreso y salida al mismo tiempo, estos indicadores se ubican antes del nombre
del parámetro.
Especificando IN, OUT, o INOUT sólo son válidos para una PROCEDURE. El procedimiento
almacenado debe de tener un cuerpo y un final, para esto se utiliza las etiquetas BEGIN y END.
Todas las instrucciones dentro del cuerpo terminan en (;), esto obliga a cambiar el delimitador (;) en
la consola, ya que los comandos del Shell lo utilizan para especificar el final de una instrucción, este
documento utilizará // como delimitador, para cambiar el delimitador natural se usa el comando
(DELIMITER //), este proceso se debe repetir cada vez que se desarrolla una procedimiento o
función almacenada, para restablecerlo se utiliza el comando (DELIMITER ;), por ejemplo:
DELIMITER //
CREATE PROCEDURE mi_procedimiento_almacenado ()
BEGIN
Proceso que desee realizar
END //
DELIMITER ;
CALL mi_procedimiento_almacenado ();
El nombre del procedimiento almacenado (store procedure) puede ser escrito en mayúsculas o
minúsculas, pues la consola no es sensible.
A la hora de ejecutar el procedimiento, es diferente a los gestores como SQL Server o Sybase donde
se hacen mediante la sentencia exec, aquí se usa la sentencia CALL y colocando al final del nombre
del procedimiento los paréntesis.
Los procedimientos almacenados no pueden usar dentro de cuerpo de desarrollo: CREATE

PROCEDURE, ALTER PROCEDURE, DROP PROCEDURE, CREATE FUNCTION, DROP FUNCTION, CREATE
TRIGGER, DROP TRIGGER. Así el uso de “USE database” no es permitido, ya que MySQL asume que
la base de datos por default es donde se creó el procedimiento.

Dentro de un procedimiento existen sentencias e instrucciones de control, que permiten gestionar

la lógica y el control de los datos, entre otros considere los siguientes:
SENTENCIA DECLARE
DECLARE nombre_variable[,...] tipo_de_dato [DEFAULT valor]
Este comando se usa para declarar variables locales, para proporcionar un valor por defecto para la
variable, se incluye una cláusula DEFAULT, el valor puede especificarse como expresión, no necesita
ser una constante. Si la cláusula DEFAULT no está presente, el valor inicial es NULL, la visibilidad o
reconocimiento de una variable local, se da dentro del bloque BEGIN ... END donde está declarado.
DECLARE var1 INT DEFAULT 0; #variables enteras
DECLARE var2 VARCHAR(15); #variables varchar también le podemos decir strings
SENTENCIA SET PARA VARIABLES
SET nombre_ var = expr [,nombre var = expr] ...
El comando SET en los procedimientos almacenados es una versión extendida del comando general
SET. Esto permite una sintaxis extendida de SET a=x, b=y, ... donde distintos tipos de variables
pueden mezclarse, por ejemplo:
SET vat1 = "hola";
SET comision = comision +(suma*0.15);
En el Shell de MYSQL también se puede aplicar asignaciones mediante SET

SET @nombre = ‘Tomas’;
SELECT @nombre;
LA SENTENCIA CALL
CALL nombre_pa([parametro[,...]])
El comando CALL ejecuta un procedimiento desarrollado previamente con CREATE PROCEDURE.
CALL puede devolver valores del procedimiento usando parámetros declarados como OUT o INOUT.
También “retorna” el número de registros afectados, que con un programa cliente puede obtenerse
a nivel SQL llamando la función ROW_COUNT() y desde C llamando la función de la API C
mysql_affected_rows() .
LA SENTENCIA SELECT ... INTO

SELECT nombre_col[,...] INTO nombre_variable[,...] expresion_tabla
Esta sintaxis permite que el resultado de un SELECT pueda almacenar desde las columnas
seleccionadas directamente a las variables; por lo tanto, sólo un registro del SELECT puede
retornarse, por ejemplo:
SELECT id,data INTO x,y FROM base.tabla LIMIT 1;
SELECT 2*7 INTO var
SELECT COUNT(*) FROM tabla WHERE condicion INTO var
SELECT Especialidad, Horas FROM medicos WHERE IdDoctor=3 INTO VarEspe, varHorasAsig

SENTENCIA IF
La sentencia IF en MySQL al igual que la mayoría de los lenguajes de programación se genera en

tres bloques, el primero es la condición en sí, el segundo es la operación a llevar se cabo si la
evaluación resulta cierta, y el tercero es la operación a efectuarse si la evaluación resulta falsa, los
bloques de verdadero o falso también pueden incluir otros bloques IF, considere la siguiente
sintaxis formal:
IF expresión THEN
-- que hacer en caso correcto
ELSE
-- que hacer en caso contrario
END IF; -- necesario para cerrar el bloque
En versiones actuales de MySQL, también es posible crear IF anidados con una sola finalización, para
estos se utiliza ELSEIF en vez de ELSE, considere la siguiente sintaxis:
IF (Num = 1) THEN
-- ..
ELSEIF (Num = 2) THEN
-- ..
ELSEIF (Num = 3) THEN
-- ..
ELSE
-- ..
END IF;
Toda condición IF debe indicar su fin, para esto se utiliza la instrucción (END IF). También se puede
hacer uso de una función IF() que se ejecuta en una sola línea y que acepta 3 argumentos, su
sintaxis es:
IF(condición, respuesta_x_Verdadero, respuesta_x_falso)
Por ejemplo:
SET valor = IF (5<5,1,0);
SELECT valor;
SELECT nombres, IF(edad <= 20, ‘Joven’, ‘Adulto’) FROM personas ORDER BY edad;
El siguiente ejemplo de procedimiento almacenado en MySQL, guarda datos de vehículos en la tabla

familiares si su velocidad es menor que 120 Km/h o en la tabla deportivos en el caso contrario:
DELIMITER //
CREATE PROCEDURE autos(IN velocidad INT, IN marca VARCHAR(50))
BEGIN
IF velocidad < 120 THEN
INSERT INTO familiares VALUES (velocidad,marca);
ELSE
INSERT INTO deportivos VALUES (velocidad,marca);
END IF;
END
//
DELIMITER;
Otro ejemplo de utilización de la instrucción de control:

delimiter //

CREATE PROCEDURE compara(IN cadena varchar(25), IN cadena2 varchar(25))

BEGIN
IF strcmp(cadena, cadena2) = 0 then
SELECT "son iguales!";
else
SELECT "son diferentes!!";
end IF;
end;
//
delimiter ;
call compara("hola","Hola");
LA SENTENCIA CASE
Esta es una herramienta condicional que nos permite evaluar el valor de una variable con varias
posibilidades. Es una forma de abreviar un montón de IF anidados. En este caso el ELSE nos permite
definir un valor por defecto (como el default en un switch/case de C, Java o PHP), la sintaxis a
aplicar pueden ser cualquiera de las siguientes:
CASE case_value
WHEN Coincidencia_Valor THEN lista_de_instrucciones
[WHEN Coincidencia_Valor THEN lista_de_instrucciones] ...
[ELSE lista_de_instrucciones]
END CASE
O:
CASE
WHEN condición_de_búsqueda THEN lista_de_instrucciones
[WHEN condición_de_búsqueda THEN lista_de_instrucciones] ...
[ELSE lista_de_instrucciones]
END CASE
Para el segundo ejemplo el comando CASE implementa un constructor condicional complejo. Si una
condición_de_búsqueda se evalúa a cierto, la lista_de_instrucciones correspondiente se ejecuta. Si
no coincide ninguna condición_de_búsqueda, la lista_de_instrucciones en la cláusula ELSE se
ejecuta.
Es importante indicar que la sintaxis de un comando CASE mostrado aquí para uso en un
procedimientos almacenados difiere ligeramente de la expresión CASE utilizado en Query SQL. El
comando CASE no puede tener una cláusula ELSE NULL y termina con END CASE en lugar de END.
Por ejemplo:
mysql>SET @x=1;
mysql> SELECT CASE @x WHEN 1 THEN 'Uno' WHEN 2 THEN 'Dos' ELSE 'Es Más' END;
-> 'one'
mysql> SELECT CASE WHEN 1>0 THEN 'true' ELSE 'false' END;
-> 'true'
mysql>SELECT ApellidoPaterno, ApellidoMaterno, nombres,
CASE EstadoCivil
WHEN "C" THEN "Casado(a)"
WHEN "S" THEN "Soltero(a)"
WHEN "V" THEN "Viudo(a)"

WHEN "U" THEN "Unión libre"

WHEN "D" THEN "Divorciado(a)" END AS "Estados Civiles"
FROM Personas;
mysql>SELECT CASE WHEN 9>7 THEN "TRUE" ELSE "FALSE" END AS "El Resultado";
mysql> SELECT CASE WHEN 10*2=30 THEN '30 es correcto'

WHEN 10*2=40 THEN '40 es correcto'
ELSE 'En caso de ser 10*2=20'
END;
mysql>SELECT CASE 10*2 WHEN 20 THEN '20 es correcto'

WHEN 30 THEN '30 es correcto'
WHEN 40 THEN '40 es correcto'
END;
Un ejemplo de procedimiento almacenado que aplique la instrucción es:

DROP PROCEDURE bienvenida;
DELIMITER //
CREATE PROCEDURE bienvenida ()
BEGIN
Declare hora time;
Set hora= CURTIME();
CASE
WHEN hora<time( '11:15:00') && hora > time('1:00:00')
THEN SELECT concat(“Buenos días ”,user(), “ son ”, hora);
WHEN hora< time('18:15:00') && hora > time('11:15:00')
THEN SELECT concat(“Buenas tardes”,user(), “ son ”, hora);
WHEN hora< time('24:00:00') && hora > time('18:15:00')
THEN SELECT concat(“Buenas noches”,user(), “ son ”, hora);
END CASE;
end; //
delimiter ;
CALL bienvenida();
El ejemplo anterior utiliza DROP PROCEDURE antes de crear el procedimiento almacenado

bienvenida, es necesario utilizarlo después de crearlo por primera vez, ya que cada cambio que se
realice al procedimiento, para probar su funcionamiento, usted deberá borrar el procedimiento y
crearlo otra vez. La función CURTIME() devuelve la hora que registra el servidor, la función TIME(),
en este procedimiento es utilizado para convertir un texto en formato hora.
SENTENCIA LOOP
LOOP es una herramienta que permite implementar un bucle repetitivo simple, éste permite
ejecutar una lista_de_instrucciones hasta finalizar el bucle, la finalización del proceso repetitivo
usualmente se cumple cuando encuentra el comando LEAVE, considere la siguiente sintaxis:
[Etiqueta_Inicio:] LOOP
lista_de_instrucciones
END LOOP [Etiqueta_Finalización]

Un comando LOOP puede o no ser etiquetado. Etiqueta_finalización no puede darse hasta que esté
presente Etiqueta_Inicio, y si ambos lo están, deben ser la misma etiqueta.
SENTENCIA LEAVE
Este comando es utilizado para abandonar cualquier control de flujo etiquetado. Puede usarse en
un bloque BEGIN ... END o en bucles, su sintaxis es:
LEAVE etiqueta;
LA SETENCIA ITERATE
ITERATE sólo puede aparecer en comandos LOOP, REPEAT, y WHILE . ITERATE significa “vuelve a
hacer el bucle.”, su sintaxis es:
ITERATE etiqueta;
Para ejemplificar el uso de estas tres herramientas, considere el siguiente ejemplo:

CREATE PROCEDURE ejemplo(valor INT)
BEGIN
label1: LOOP
SET valor = valor + 1;
IF valor < 10 THEN ITERATE label1; END IF;
LEAVE label1;
END LOOP label1;
SET x = valor;
……..
END
Aplicando un ejemplo práctico, el siguiente procedimiento almacenado muestra el nombre
“Gabriel” 10 veces:
Delimiter //
CREATE PROCEDURE ejemplo1()
BEGIN
DECLARE x int default 1;
xxx:LOOP
SELECT "Gabriel" As nombre,x As Contador;
IF x>=10 THEN leave xxx; END IF;
set x=x+1;
END LOOP xxx;
END//
Delimiter ;
Para ejecutar el procedimiento ejemplo1, ejecute la siguiente orden:
mysql>CALL ejemplo1();
SENTENCIA REPEAT
[Etiqueta_Inicio:] REPEAT
UNTIL condición_de_búsqueda
END REPEAT [Etiqueta_Finalización]
La lista_de_instrucciones dentro de un bucle REPEAT se repite hasta que la condición_de_búsqueda

sea verdadera, es decir que estará repitiendo mientra la condición sea falsa.

Un comando REPEAT al igual que el comando LOOP puede o no etiquetarse, así también
etiqueda_Finalización no puede darse a no ser que Etiqueta_Inicio esté presente, y si lo están,
deben ser la misma etiqueta, considera el siguiente ejemplo:
delimiter //
CREATE PROCEDURE UsandoRepeat(valor INT)
BEGIN
SET x = 0;
REPEAT SET x = x + 1; UNTIL x > valor END REPEAT;
END //
CALL dorepeat(1000)//
SELECT x//
En el ejemplo note que el delimitador no se lo cambia al normal (;), Considerando el ejemplo que
muestra 10 veces el nombre “Gabriel”, al utilizar REPEAT sería:
Delimiter //
BEGIN
declare x int default 1;
REPEAT
select "Gabriel" As nombre,x As Contador;
set x=x+1;
UNTIL x>10 END REPEAT;
END//
Delimiter ;
SENTENCIA WHILE
[Etiqueta_Inicio:] WHILE condición_de_búsqueda DO
END WHILE [Etiqueta_Finalización]
A diferencia del bucle REPEAT, La lista_de_instrucciones dentro de un bucle WHILE se repite

mientras la condición condición_de_búsqueda sea verdadera. Un bucle WHILE puede o no
etiquetarse. Etiqueta_Finalización no puede darse a no ser que Etiqueta_Inicio también esté
presente, y si lo están, deben ser el mismo. Por ejemplo:
CREATE PROCEDURE Usowhile()
BEGIN
DECLARE v1 INT DEFAULT 5;
WHILE v1 > 0 DO
... SET v1 = v1 - 1;
END WHILE;
END
Considerando el ejemplo que muestra 10 veces el nombre “Gabriel”, al utilizar WHILE sería:
Delimiter //
BEGIN
declare x int default 1;
WHILE x<=10 DO
select "Gabriel" As nombre,x As Contador;
set x=x+1;
END WHILE;
END//
Delimiter ;

Para eliminar procedimientos almacenados se utiliza la instrucción DROP PROCEDURE, que ya se ha

tratado en uno de los apartados anteriores, a esta instrucción se le puede agregar el complemento
IF EXISTS para evitar errores en caso de no existir en la base de datos, su sintaxis es:
DROP PROCEDURE IF EXISTS nombre_pa;
FORMAS DE MOSTRAR EL LISTADO DE PROCEDIMIENTOS ALMACENADOS
Los procedimientos almacenados que se crean para ser utilizadas en cualquier base de datos, se
registra en la base de datos administrativa de MySQL, para mostrar la lista de procedimientos
almacenados creados, se lo puede hacer desde la ubicación de la base de datos principal de MySQL
o desde otra ubicación.
 Desde la ubicación de la base de datos principal de MySQL:

mysql>USE mysql;
mysql>SELECT specific_name FROM proc;
o también:
mysql>SELECT specific_name FROM proc WHERE type=’procedure’;
 Desde la ubicación de la base de datos en la que se está trabajando:
mysql>SHOW PROCEDURE STATUS;
De igual forma para mostrar el contenido lógico de un procedimiento almacenado se aplica:

 Desde la base de datos principal de MySQL:
mysql> USE mysql;
mysql> SELECT specific_name, body FROM proc WHERE specific_name='nombre_procedimiento';
 Desde la base de datos en la que se está trabajando:

mysql> SHOW CREATE PROCEDURE 'nombre_procedimiento;
EJERCICIOS DE APLICACIÓN DE PROCEDIMIENTOS ALMACENADOS
El siguiente ejemplo de creación de procedimiento almacenado, permite ingresar datos sobre la

tabla “Personas”, oculta el diseño original de la tabla, ya que el programador o quién tenga la
necesidad de utilizarla, solo tendrá que emplear el nombre del procedimiento y pasar sus
argumentos y no identificar el diseño de la tabla y sus campos al emplear el INSERT INTO:
DROP PROCEDURE IF EXISTS AgregaDatosPersonales;
CREATE PROCEDURE AgregaDatosPersonales (IN ApPat varchar(50),IN ApMat varchar(50),IN Nomb
varchar(50),IN Direc varchar(150),IN fono varchar(15),IN sex varchar(1),IN FechaN Date,IN EstCivil
varchar(1))
FechaNacimiento, EstadoCivil) VALUES (ApPat,ApMat,Nomb,Direc,fono,sex,FechaN,EstCivil);
Éste procedimiento almacenado no utiliza BEGIN.. END ya que solo tiene una sola instrucción Insert
Into, utiliza o 8 parámetros de la estructura de la tabla. Para utilizar la tabla aplique el siguiente
ejemplo:
CALL AgregaDatosPersonales ('Farías','Pincay','Marcos Javier','Playa Prieta, Calle Principal',
'0997123456', 'M', '1998-11-20','U');

El siguiente ejemplo crea un procedimiento almacenado para buscar y obtener el identificador

único de la persona “IDPersona”, para esto se le pasará el nombre y apellidos de la persona a
localizar:
DROP PROCEDURE IF EXISTS BuscaId;
CREATE PROCEDURE BuscaId(OUT IdBuscar integer, IN ApPat varchar(50), IN ApMat varchar(50), IN
Nomb varchar(50))
SELECT IdPersona INTO IdBuscar FROM Personas
WHERE concat(ApellidoPaterno,' ', ApellidoMaterno,' ', Nombres)=concat(ApPat,' ',ApMat,' ',Nomb);
El ejemplo aplica la asignación mediante SELECT INTO cuando se cumple la condición WHERE, la
asignación es dada a la variable “IdBuscar” que esta definida como de salida (OUT).
El siguiente ejemplo crea un procedimiento almacenado que permite ingresar datos sobre las tablas
“Personas” y “Profesores”, oculta el diseño original de ambas tablas, ya que el programador o quién
tenga la necesidad de utilizarla, solo tendrá que emplear el nombre del procedimiento y pasar sus
argumentos y no podrá identificar el diseño de ambas tablas, de hecho no tendrá idea, que se trata
de 2 tablas:
DROP PROCEDURE IF EXISTS AgregaProfesores;
DELIMITER //
CREATE PROCEDURE AgregaProfesores (ApPat varchar(50),ApMat varchar(50),Nomb
varchar(50),Direc varchar(150),fono varchar(15),sex varchar(1), FechaN Date, EstCivil
varchar(1),cargo Varchar(50), Titulacion Varchar(50), Fechaingreso date)
BEGIN
DECLARE Id INTEGER;
CALL AgregaDatosPersonales(ApPat,ApMat,Nomb,Direc,fono,sex,FechaN,EstCivil);
SELECT MAX(IdPersona) INTO Id FROM Personas;
INSERT INTO Profesores(IdPersona, cargo, Titulacion, Fechaingreso) VALUES (Id, cargo, Titulacion,
Fechaingreso);
END//
DELIMITER ;
Los argumentos utilizados en este ejemplo, son los mismos empleados en el procedimiento
“AgregaDatosPersonales” más los datos de la tabla “Profesores”, aquí se aplica el llamado al
procedimiento “AgregaDatosPersonales”, que permiten registrar los datos personales del profesor,
posterior a esto, se obtiene el mayor de todos los identificadores y lo asigna a la variable “Id”, éste
método de obtención de identificador no es recomendable, sí existen multiples usuarios conectados
a la base de datos, lo recomendable es utilizar el procedimiento “BuscaId”, pero es bueno observar
otras perspectivas. Para aplicar el uso de este procedimiento almacenado, utilice la siguiente
instrucción:
CALL AgregaProfesores ('Mero','Casanova','Boris Mareano','Calderon, diagonal al colegio',
'097654321','M','1999-06-11','C','Profesor','Ingeniero Civil','2009-01-05');

En el siguiente ejemplo, se crea un procedimiento almacenado similar al anterior, la diferencia es su

aplicabilidad a la tabla “Padres”, básicamente utiliza los mismos argumentos de la tabla “Personas”
más los datos de la tabla “Padres”:
DROP PROCEDURE IF EXISTS AgregaPadres;
Delimiter //
CREATE PROCEDURE AgregaPadres (ApPat varchar(50),ApMat varchar(50),Nomb varchar(50),Direc
varchar(150),fono varchar(15),sex varchar(1), FechaN Date, EstCivil varchar(1),cargasf int(2),
fonoTrabajo Varchar(15), DirecTrabajo varchar(100), ocupacion varchar(80))
BEGIN
DECLARE Id INTEGER;
SELECT MAX(IdPersona) INTO Id FROM Personas;
INSERT INTO Padres(IdPersona, cargasfamiliares, TelefonoTrabajo, DireccionTrabajo, ocupacion)
VALUES (Id, cargasf, fonoTrabajo, DirecTrabajo, ocupacion);
END//
delimiter ;
Para probar su funcionalidad aplique el siguiente ejemplo:

CALL AgregaPadres ('Mendieta','Alvarado','Carmen Alina','Cdla PortoNorte casa 16', '052987654', 'F',
'1979-12-02', 'C', 3,'053789456','Montecristi, Asamblea','Asistente contable');
El siguiente procedimiento almacenado es más extenso que los anteriores ya que para agregar
datos de un estudiante, se necesita los apellidos y nombres de sus padres, utiliza los mismos
argumentos de la tabla “Personas” más los datos de la tabla “Estudiante”, el ejemplo aplica los
procedimientos almacenados desarrollados anteriormente y aplica los mismos criterios de lógica:
DROP PROCEDURE IF EXISTS AgregaEstudiantes;
Delimiter //
CREATE PROCEDURE AgregaEstudiantes (ApPat varchar(50),ApMat varchar(50),Nomb
varchar(50),Direc varchar(150),fono varchar(15),sex varchar(1),FechaN Date, EstCivil varchar(1),
ApPatPP varchar(50),ApMatPP varchar(50),NombPP varchar(50),
ApPatMM varchar(50),ApMatMM varchar(50),NombMM varchar(50), Proce varchar(80))
BEGIN
DECLARE IdEst INTEGER;
DECLARE IdPapa INTEGER;
DECLARE IdMama INTEGER;
CALL BuscaId(IdPapa,ApPatPP,ApMatPP,NombPP);
CALL BuscaId(IdMama,ApPatMM,ApMatMM,NombMM);
CALL BuscaId(IdEst,ApPat,ApMat,Nomb);
INSERT INTO Estudiante(IdPersona, IdPersonaPapa, IdPersonaMama, Procedencia)

VALUES (IdEst, IdPapa, IdMama, Proce);
END//
Delimiter ;
Para utilizar el procedimiento, aplicamos la siguiente instrucción:
CALL AgregaEstudiantes('Farías','Mendieta','Andrea Patricia','Playa Prieta Calle Principal',

'0998444333', 'F', '2002-10-10','S','Farías','Pincay','Marcos Javier','Mendieta','Alvarado','Carmen
Alina','Escuela 12 de Mayo');
Otro ejemplo de procedimiento almacenado, se plicaría para obtener totales, el siguiente

procedimiento devuelve el total de personas registradas en la tabla “Personas”
DROP PROCEDURE IF EXISTS Totalpersonas;
Delimiter //
CREATE PROCEDURE Totalpersonas (OUT Total INT)
SELECT COUNT(*) INTO Total FROM Personas;
//
Delimiter ;
Para utilizarlo realizaremos lo siguiente:
CALL Totalpersonas(@a);
SELECT @a;
Para ver el listado de procedimientos almacenados que se han creado, aplique el siguiente
comando:
SHOW PROCEDURE STATUS;
EJERCICIOS PROPUESTOS
Se necesita crear varios procedimientos almacenados que complementen la matriculación, para
esto se necesita los siguientes procesos:
1. Un procedimiento almacenado para obtener el IdEspecialidad, para esto se utiliza como
argumento el identificador a devolver y el nombre de la especialidad.
2. Un procedimiento almacenado para obtener el Idcurso, para esto se utiliza como argumento
el identificador a devolver y el nombre del curso.
3. Un procedimiento almacenado para obtener el Idparalelo, para esto se utiliza como
argumento el identificador a devolver y la letra del paralelo
4. Crear un procedimiento almacenado que permita registra la matriculación de un estudiante.
TAREA 10: Desarrolle el diseño de una base de datos para un consultorio médico, el doctor
necesita registrar los datos personales del paciente, sus visitas médicas, en caso de existir también
necesita registrar los datos de intervenciones quirúrgicas de sus paciente, es importante destacar
que algunos pacientes de limitados recursos económicos tienen crédito que pueden ser pagados
poco a poco; se necesita justificar el diseño de su propuesta y los procedimientos necesarios para
lograr cumplir con los objetivos del consultorio.

FUNCIONES EN MYSQL
Considerando lo expuesto en el capitulo de procedimientos almacenados, las funciones poseen el

siguiente formato:
CREATE FUNCTION nombre_función ([parametro[,...]]) RETURNS tipo_de_dato_a_devolver
[Característica ...] cuerpo_de_desarrollo
La cláusula RETURNS puede especificarse sólo con FUNCTION, donde su definición es obligatoria. Se
usa para indicar el tipo de retorno de la función, y el cuerpo de la función debe contener un
comando “RETURN valor”. La lista de parámetros entre paréntesis debe estar siempre presente. Si
no hay parámetros, se debe usar una lista de parámetros vacía (). Cada parámetro es un parámetro
IN por defecto.
Un procedimiento o función se considera “determinista” si siempre produce el mismo resultado

para los mismos parámetros de entrada, y “no determinista” en cualquier otro caso. Sí no se da ni
DETERMINISTIC ni NOT DETERMINISTIC por defecto es NOT DETERMINISTIC. Un ejemplo de uso de
funciones es la siguiente:
CREATE FUNCTION hola (s CHAR(20)) RETURNS CHAR(50)
RETURN CONCAT('Hola, ',s,'!');
mysql> SELECT hola('Gabriel');
Si al crear y ejecutar la función se muestra el siguiente error:

ERROR 1418 (HY000): This function has none of DETERMINISTIC, NO SQL, or READS SQ
L DATA in its declaration and binary logging is enabled (you *might* want to use
the less safe log_bin_trust_function_creators variable)
Se soluciona este problema utilizando la siguiente instrucción:

mysql> set Global log_bin_trust_function_creators=1;
Para mostrar la lista de funciones creadas se utiliza la instrucción:

SHOW FUNCTION STATUS
Si se desea hacer una función que devuelva la fecha con el formato ‘dia de semana numero de mes
y año’, se podría realizar lo siguiente:
DROP FUNCTION IF EXISTS FechaLarga;
DELIMITER //
CREATE FUNCTION FechaLarga(fech DATETIME) RETURNS char(50)
BEGIN
RETURN date_format(fech,’%W %d de %M de %Y’);
END //
DELIMITER ;
Para probar el uso de la función se aplica:
SELECT nombres, FechaLarga(fechaNacimiento) FROM personas WHERE idpersona<5;
Al ejecutar la línea anterior notará que se muestra el formato en ingles, una alternativa a esta
situación es la creación de la siguiente función:
DROP FUNCTION IF EXISTS Fechacompleta;
DELIMITER //
CREATE FUNCTION Fechacompleta(fecha DATETIME) RETURNS varchar(150)
BEGIN

DECLARE dia INT;

DECLARE mes INT;
DECLARE dia_s VARCHAR(20);
DECLARE mes_s VARCHAR(20);
DECLARE fecha_f VARCHAR(150);
SET dia = DAYOFWEEK(fecha);
SET mes = MONTH(fecha);
CASE dia
WHEN 1 THEN SET dia_s = ‘Domingo’;
WHEN 2 THEN SET dia_s = ‘Lunes’;
WHEN 3 THEN SET dia_s = ‘Martes’;
WHEN 4 THEN SET dia_s = ‘Miercoles’;
WHEN 5 THEN SET dia_s = ‘Jueves’;
WHEN 6 THEN SET dia_s = ‘Viernes’;
WHEN 7 THEN SET dia_s = ‘Sabado’;
END CASE;
CASE mes
WHEN 1 THEN SET mes_s = ‘Enero’;
WHEN 2 THEN SET mes_s = ‘Febrero’;
WHEN 3 THEN SET mes_s = ‘Marzo’;
WHEN 4 THEN SET mes_s = ‘Abril’;
WHEN 5 THEN SET mes_s = ‘Mayo’;
WHEN 6 THEN SET mes_s = ‘Junio’;
WHEN 7 THEN SET mes_s = ‘Julio’;
WHEN 8 THEN SET mes_s = ‘Agosto’;
WHEN 9 THEN SET mes_s = ‘Septiembre’;
WHEN 10 THEN SET mes_s = ‘Octubre’;
WHEN 11 THEN SET mes_s = ‘Noviembre’;
WHEN 12 THEN SET mes_s = ‘Diciembre’;
END CASE;
SET fecha_f = CONCAT(dia_s,’ ‘,DAY(fecha),’ ‘,mes_s,’ ‘,YEAR(fecha));
RETURN fecha_f;
END //
DELIMITER ;
Para aplicar el uso de la función:
SELECT ApellidoPaterno,ApellidoMaterno, Nombres, if(sexo='F','Femenino','Masculino') As sexo,
Fechacompleta (FechaNacimiento) AS Nacimiento FROM personas WHERE idpersona<5;
Otros ejemplos de funciones se presentan a continuación:

DROP FUNCTION IF EXISTS cuadrado;
DELIMITER //
CREATE FUNCTION cuadrado (s SMALLINT) RETURNS SMALLINT
RETURN s*s;
//
DELIMITER ;
Para probar el funcionamiento de esta función:
mysql> SELECT cuadrado(2);
La siguiente función calcula la edad:

DELIMITER //
CREATE FUNCTION Edad(fech DATETIME) RETURNS char(14)
BEGIN
RETURN (YEAR(CURDATE())-YEAR(fech)) - (RIGHT(CURDATE(),5)<RIGHT(fech,5));
END //
DELIMITER ;

Para probar el funcionamiento de la función:

SELECT ApellidoPaterno,ApellidoMaterno, Nombres, Edad(FechaNacimiento) AS Edad FROM
personas;
El siguiente ejemplo crea una función que acepta como argumento un dividendo y un divisor y
realiza una división sin usar el operador de división:
delimiter //
CREATE FUNCTION divide(dividendo int,divisor int) returns int
Begin
declare aux int;
declare contador int;
declare resto int;
set contador = 0;
set aux = 0;
while (aux + divisor) <= dividendo do
set aux = aux + divisor ;
set contador = contador + 1;
end while;
set resto = dividendo - aux ;
return contador;
END; //
delimiter ;
La siguiente function compara 2 cadenas de caracteres y devuelve el número mayor de caracteres:

delimiter //
CREATE FUNCTION cadena_mas_larga(in_uno char(100),in_dos char(100)) RETURNS int
BEGIN
DECLARE lon_uno int;
DECLARE lon_dos int;
DECLARE result int;
SET lon_uno= LENGTH(in_uno);
SET lon_dos = LENGTH(in_dos);
IF lon_uno > lon_dos THEN
RETURN lon_uno;
ELSE
RETURN lon_dos;
END IF;
END //
delimiter ;
Para probarlo:
SELECT cadena_mas_larga('Hola Mundo','Hola Universidad Técnica de Manabí');
El siguiente ejemplo muestra el número de veces que se repite un carácter en un texto:

Delimiter //
CREATE FUNCTION cuenta_caracter(intext char(100), inchar char(2)) RETURNS INT
BEGIN
DECLARE lon int;
DECLARE resultado int;
DECLARE i int;
DECLARE tmp char;
SET lon= length(intext)+1;
SET i=1;
SET resultado=0;

WHILE i <= lon DO

SET tmp = substr(intext,i,1);
IF tmp = inchar THEN
SET resultado = resultado +1;
END IF;
SET i=i+1;
END WHILE;
RETURN resultado;
END//
Delimiter ;
Para ejecutarlo:
SELECT cuenta_caracter('Todo nos es lisito pero no todo nos conviene','o');
Asumiendo que se necesita una función que devuelva el total de varones o de mujeres registrados
en la tabla Personas, se tendría que realizar lo siguiente:
DELIMITER //
CREATE FUNCTION Total(sex char(2)) RETURNS INT
BEGIN
DECLARE total INT;
SELECT COUNT(*) INTO total FROM personas WHERE sexo=sex;
RETURN total;
END //
DELIMITER ;
Para comprobar su funcionamiento:
SELECT total(‘M’);
SELECT total(‘F’);
COMO AGREGAR COMENTARIOS

En las rutinas de MySQL, los comentarios pueden hacerse de tres maneras:
 Empezando una línea con "#":
# Este es un comentario
 Encerrando un texto entre "/*" y "*/":
/* Este es un comentario de una línea */
/* Este es un comentario
que abarca
varias líneas */
 Anteponiendo a una línea dos guiones y un espacio:
--
-- Este es un comentario
--
EJERCICIOS PROPUESTOS
1. Elabore una función que permita calcular la factorial de un número.
2. Elabore una función que devuelva el número de hijos que tiene registrados en la base de
datos, utilice como argumento el identificador del padre.
TAREA 11: Desarrolle una función que permita transformar un valor a su correspondencia en
letras, la función debe recibir como argumento una catidad entera positiva, justifique su propuesta
lógica, no es requerido, pero si utiliza un argumento son 2 decimales y devuelve su equivalencia en
letras, se le asignará puntos extras que sustituirá a una tarea no presentada.

CURSORES EN MYSQL
En el lenguaje SQL existen unos tipos de controles llamados cursores que son útiles para recorrer los
registros que devuelve una consulta. Este tipo de estructuras sólo deben utilizarse cuando no haya
otra forma de manipular conjuntos de datos en una sola instrucción. Los cursores no son sensibles
(No sensible significa que el servidor puede o no hacer una copia de su tabla de resultados), son de
sólo lectura, y no permiten scrolling.
DELIMITER //
DROP PROCEDURE IF EXISTS micursor//
CREATE PROCEDURE micursor()
BEGIN
DECLARE done BOOLEAN DEFAULT FALSE;
DECLARE uid integer;
DECLARE newdate integer;
DECLARE c1 cursor FOR Select id,timestamp From employers ORDER BY id ASC;

DECLARE CONTINUE HANDLER FOR SQLSTATE '02000' SET done = TRUE;
OPEN c1;
c1_loop: LOOP
FETCH c1 INTO uid, newdate;
IF done THEN LEAVE c1_loop; END IF;
UPDATE calendar SET timestamp=newdate WHERE id=uid;
END LOOP c1_loop;
close c1;
END //
Los cursores deben declararse antes de declarar los handlers, y las variables y condiciones deben
declararse antes de declarar cursores o handlers.
Un handler (manejadores) en MySQL es invocado cuando se da un evento o condición definida con

anterioridad. Este evento está siempre asociado con una condición de error, pero puedes tener tres
formas de definir el error:
 Como código de error de MySQL

 Como código SQLSTATE ANSI-standard
 Como nombre de condición, ejemplo: SQLEXCEPTION,SQLWARNING y NOT FOUND.
MySQL tiene sus propios códigos de error que son únicos para MySQL Server. Por ejemplo:
DECLARE CONTINUE HANDLER FOR 1062 SET duplicate_key=1;
Un código de error SQLSTATE es definido por ANSI standard y son independientes de la base de
datos, lo que significa que deberías tener el mismo valor de error para cualquier base de datos ANSI
compatible. Por ejemplo:
DECLARE CONTINUE HANDLER FOR SQLSTATE '23000' SET duplicate_key=1;

Así, Oracle, SQL Server, DB2, y MySQL reportarán el mismo SQLSTATEvalue (23000) cuando hay un
error de primary key duplicada..
CREATE PROCEDURE ...
BEGIN
-- Declaro el handler que al darse una condicion
-- continue su ejecucion, pero registre un flag
SET flag=0;
DECLARE CONTINUE HANDLER FOR SQLSTATE '23000' SET flag = 1;
INSERT INTO TABLA........;
-- Si flag=1 es porque se dio la condicion SQLSTATE '23000'
-- (23000, en realidad, engloba muchos errores de violacion)
-- Como no se ejecuto el INSERT entonces probamos con UPDATE.
IF flag = 1 THEN
UPDATE TABLA...........;
END IF;
END
Sentencia CLOSE
CLOSE nombre_de_cursor
Cierra el cursor, el cual deberá estar abierto. Un cursor abierto es cerrado automáticamente cuando
el bloque BEGIN dentro del cual está termina.
Sentencia FETCH
FETCH [[NEXT] FROM] nombre_de_cursor INTO variable [, variable2,…]
Obtiene el siguiente renglón para el cursor actual y almacena cada una de sus columnas en las
variables mencionadas. El cursor debe estar abierto. Si no está disponible ningún renglón, un error
con un valor de SQLSTATE igual a 02000 ocurre.
Sentencia OPEN
OPEN nombre_de_cursor
Abre el cursor para que pueda ser utilizado con la instrucción FETCH.
Para realizar ejercicios que sirvan de ejemplo en la utilización de cursores, se agragarán 3 nuevas
tablas, La tabla “TiposAsignaturas” permitirá registrar catrgorías como: Area, comisión, matria y
encargos que pueden ocupar tiempo asignado a los docentes, la tabla “Materia” registrará de forma
única los nombres de las diferentes materias como: Ciencias Naturales, Lengua, Matemáticas, entre
otras, La Tabla “MatriasProfesores” registrará que materias tendrá a su cargo cada docente,
especialidad, curso, paralelo, periodo lectivo y el número de hora que tiene la materia.
Para ilustrar lo esplicado considere la siguiente imagen que muestra las tablas involucradas y su
respectiva relación, asi también las correspondientes instrucciones SQL que crean de las tres tablas:

CREATE TABLE IF NOT EXISTS TiposAsignaturas(

IdTipoAsignatura int(11) NOT NULL AUTO_INCREMENT,
NombreTipoAsignatura varchar(75) DEFAULT NULL,
PRIMARY KEY (IdTipoAsignatura)
);
CREATE TABLE IF NOT EXISTS Materias(

IdMateria int(11) NOT NULL AUTO_INCREMENT,
NombreMateria varchar(80) NOT NULL,
IdTipoAsignatura int(11) NOT NULL,
PRIMARY KEY (IdMateria),
FOREIGN KEY (IdTipoAsignatura) REFERENCES TiposAsignaturas(IdTipoAsignatura)
);
CREATE TABLE IF NOT EXISTS materiasprofesores (

IdMateriaProfesor int(11) NOT NULL AUTO_INCREMENT,
IdPersonaProfesor int(11) NOT NULL,
IdMateria int(11) NOT NULL,
IdPeriodoLectivo int(11) NOT NULL,
IdEspecialidad int(11) NOT NULL,
IdCurso int(11) NOT NULL,
iDParalelo int(11) NOT NULL,
NumeroHoras int(11) DEFAULT NULL,
PRIMARY KEY (IdMateriaProfesor),
FOREIGN KEY (IdPersonaProfesor) REFERENCES Personas(IdPersonaProfesor),
FOREIGN KEY (IdMateria) REFERENCES Materias(IdMateria),
FOREIGN KEY (IdPeriodoLectivo) REFERENCES PeriodosLectivos(IdPeriodoLectivo),
FOREIGN KEY (IdEspecialidad) REFERENCES Especialidades(IdEspecialidad),
FOREIGN KEY (IdCurso) REFERENCES Cursos(IdCurso),
FOREIGN KEY (iDParalelo) REFERENCES Paralelos(iDParalelo)
);

Los datos a registrar por el momento son:

INSERT INTO TiposAsignaturas(IdTipoAsignatura,NombreTipoAsignatura)
VALUES (1, 'MATERIA'),(2, 'AREA'),(3, 'COMISION'),(4, 'ENCARGO');
INSERT INTO Materias (IdMateria, NombreMateria, IdTipoAsignatura) VALUES

(1, 'MATEMATICAS', 1),
(2, 'DIBUJO', 1),
(3, 'CULTURA FISICA', 1),
(4, 'AREA DE SOCIALES', 2),
(5, 'COMISION DE DEPORTES', 3),
(6, 'QUIMICA', 1),
(7, 'COMISION SOCIAL', 3),
(8, 'CIENCIAS NATURALES', 1),
(9, 'INGLES', 1),
(10, 'CIENCIAS SOCIALES', 1),
(11, 'COMISION ACADEMICA', 3),
(12, 'COMISION DE DISCIPLINA', 3),
(13, 'HISTORIA',1),
(14, 'FISICA',1),
(15, 'COMPUTACION', 1);
INSERT INTO materiasprofesores(IdMateriaProfesor, IdPersonaProfesor, IdMateria, IdPeriodoLectivo,

IdEspecialidad, IdCurso, iDParalelo, NumeroHoras) VALUES
(1, 1, 1, 2, 3, 1, 1, 3),
(2, 1, 1, 2, 2, 2, 1, 4),
(3, 2, 2, 2, 2, 1, 1, 2),
(4, 2, 6, 2, 2, 3, 1, 4),
(5, 3, 3, 2, 3, 1, 1, 2),
(6, 4, 6, 2, 3, 2, 1, 4),
(7, 14, 14, 2, 2, 3, 1, 4),
(8, 13, 13, 2, 2, 2, 1, 2),
(9, 10, 14, 2, 3, 1, 1, 2);
Asumamos que se necesita un procedimiento almacenado que utilizando cursores, permita agregar
profesores a la “Comisión Social” de la institución, las autoridades han dispuesto que los profesores
que tienen asignado materias como la de Ingles, cultura física y dibujo se les asigne 2 horas a la
semana en su carga horaria.
Para chequear la distribución horaria se aplica la siguiente consulta:

SELECT ApellidoPaterno, ApellidoMaterno, Nombres, materias.NombreMateria, materiasprofesores.NumeroHoras
FROM Personas, materias, materiasprofesores
WHERE materias.IdMateria = materiasprofesores.IdMateria
AND personas.IdPersona = materiasprofesores.IdPersonaProfesor;
Después incluimos el siguiente procedimiento almacenado

Delimiter //
CREATE PROCEDURE AsignaComisionSocial()
BEGIN
DECLARE Limite BOOLEAN DEFAULT FALSE;
DECLARE v_IdPeriodoActual INTEGER;
DECLARE v_IdMateria INTEGER;
DECLARE v_IdProfesor INTEGER;
DECLARE v_IdEspecialidad INTEGER;
DECLARE v_IdCurso INTEGER;
DECLARE v_IdParalelo INTEGER;
#Llenado del cursor mediante la consulta
DECLARE Lista cursor for SELECT IdPersonaProfesor, IdEspecialidad, IdCurso, iDParalelo FROM materias,
materiasprofesores WHERE materias.IdMateria = materiasprofesores.IdMateria AND
materias.NombreMateria IN ('DIBUJO','CULTURA FISICA','INGLES') GROUP BY idpersonaprofesor;
DECLARE CONTINUE HANDLER FOR SQLSTATE '02000' SET Limite = TRUE;
#Para obtener el identificador del periodo lectivo actual
SELECT Max(IdPeriodoLectivo) INTO v_IdPeriodoActual FROM PeriodosLectivos;
#Para Obtener el identificador de “Comisión Social”
SELECT IdMateria INTO v_IdMateria FROM Materias WHERE NombreMateria=’COMISION SOCIAL’;
OPEN Lista;
c1_loop: LOOP
FETCH Lista INTO v_IdProfesor, v_IdEspecialidad, v_IdCurso, v_IdParalelo;
IF Limite THEN LEAVE c1_loop; END IF;
#Agrega al profesor a su carga la “Comisión Social”
INSERT INTO materiasprofesores ( IdPersonaProfesor, IdMateria, IdPeriodoLectivo,
IdEspecialidad, IdCurso, iDParalelo, NumeroHoras) VALUES (v_IdProfesor, v_IdMateria ,
v_IdPeriodoActual ,v_IdEspecialidad, v_IdCurso, v_IdParalelo,2);
END LOOP c1_loop;
CLOSE Lista;
END //
delimiter ;
Para probar el funcionamiento se aplica las siguientes instrucciones:

CALL AsignaComisionSocial();
FROM personas INNER JOIN (materias INNER JOIN materiasprofesores ON materias.IdMateria =
materiasprofesores.IdMateria) ON personas.IdPersona = materiasprofesores.IdPersonaProfesor;
EJERCICIO PROPUESTO:
Modofique el procedimiento almacenado que asigna profesores de dibujo, ingles y cultura física a la
comisión social, de manera que se le pueda pasar como argumento el nombre de la materia, el
nombre de la comisión a ser asignado y el número de horas.
TAREA 12: Desarrolle un procedimiento almacenado con cursores que permita mostrar la lista de
profesores indicando el número de horas asignados en materias, el número de horas asignadas en
otras actividades.

TRANSACCIONES
Como ya se ha expresado en contenidos anteriores, el servidor de bases de datos MySQL soporta

distintos tipos de ingeniería para la gestión de tablas, entre estos ISAM, MyISAM, InnoDB y BDB
(Berkeley Database), entre otros. De éstos, InnoDB es el tipo de tabla más importante (después del
tipo predeterminado, MyISAM).
La diferencia radica en que las tablas del tipo InnoDB están estructuradas de forma distinta que
MyISAM, ya que se almacenan en un sólo archivo en lugar de tres, y sus principales características
permite el trabajo con transacciones, además de definir reglas de integridad referencial.
Las transacciones aportan una fiabilidad superior a las bases de datos, ya que si se dispone de una
serie de consultas SQL que deben ejecutarse en conjunto, con el uso de transacciones se puede
tener la certeza de que nunca se quedará a medio camino de su ejecución. De hecho, se podría
decir que las transacciones aportan una característica de "deshacer" a las aplicaciones de bases de
datos.
Las tablas que soportan transacciones, como el caso de InnoDB, son mucho más seguras y fáciles de
recuperar si se produce algún fallo en el servidor, ya que las consultas se ejecutan o no en su
totalidad. Como una desventaja, es importante destacar que las transacciones pueden hacer que las
consultas tarden más tiempo en ejecutarse.
En efecto, una de las principales características de las tablas del tipo InnoDB es que pueden trabajar
con transacciones, o sentencias SQL que son agrupadas como una sola. Un ejemplo típico de esto es
una transacción bancaria. Por ejemplo, si una cantidad de dinero es transferida de la cuenta de una
persona a otra, se requerirán por lo menos dos consultas:
UPDATE cuentas SET balance = balance - cantidad_transferida WHERE cliente = persona1;
UPDATE cuentas SET balance = balance + cantidad_transferida WHERE cliente = persona2;
Estas dos consultas deben trabajar bien, ¿pero que sucede si ocurre algún imprevisto y "se cae" el
sistema después de que se ejecuta la primer consulta, pero la segunda aún no se ha completado?.
La persona1 tendrá una cantidad de dinero removida de su cuenta, y creerá que ha realizado su
pago, sin embargo, la persona2 estará enfadada puesto que pensará que no se le ha depositado el
dinero que le deben. En este ejemplo tan sencillo se ilustra la necesidad de que las consultas sean
ejecutadas de manera conjunta, o en su caso, que no se ejecute ninguna de ellas. Es aquí donde las
transacciones toman un papel muy importante.
Los pasos para usar transacciones en MySQL son:

 Iniciar una transacción con el uso de la sentencia BEGIN.
 Actualizar, insertar o eliminar registros en la base de datos.
 Si se quieren los cambios a la base de datos, completar la transacción con el uso de la
sentencia COMMIT. Únicamente cuando se procesa un COMMIT los cambios hechos por las
consultas serán permanentes.
 Si sucede algún problema, podemos hacer uso de la sentencia ROLLBACK para cancelar los
cambios que han sido realizados por las consultas que han sido ejecutadas hasta el
momento.
Vamos a ejecutar algunas consultas para ver como trabajan las transacciones. Lo primero que
tenemos que hacer es crear una tabla del tipo InnoDB e insertar algunos datos.

Para crear una tabla InnoDB, procedemos con el código SQL estándar CREATE TABLE, pero debemos
especificar que se trata de una tabla del tipo InnoDB (TYPE= InnoDB). Esto es aplicable a cualquier
tipo de tabla, pero cuando no se especifica nada, MySQL supone que se trata de una tabla MyISAM.
CREATE TABLE ejemplo (campo INT NOT NULL PRIMARY KEY) TYPE = InnoDB;
INSERT INTO ejemplo VALUES(1);
mysql> SELECT * FROM ejemplo;

+-------+
| campo |
+-------+
| 1|
| 2|
| 3|
+-------+
Ahora veamos como usar transacciones.

mysql> BEGIN;
mysql> INSERT INTO ejemplo VALUES(4);
+-------+
| campo |
+-------+
| 1|
| 2|
| 3|
| 4|
+-------+
Si en este momento ejecutamos un ROLLBACK, la transacción no será completada, y los cambios

realizados sobre la tabla no tendrán efecto.
mysql> ROLLBACK;
+-------+
| campo |
+-------+
| 1|
| 2|
| 3|
+-------+
Ahora vamos a ver que sucede si perdemos la conexión al servidor antes de que la transacción sea
completada.
mysql> BEGIN;
mysql> INSERT INTO ejemplo VALUES(4);
+-------+
| campo |
+-------+
| 1|
| 2|
| 3|

| 4|
+-------+
mysql> EXIT;
Bye
Cuando obtengamos de nuevo la conexión, podemos verificar que el registro no se insertó, ya que
la transacción no fue completada.
+-------+
| campo |
+-------+
| 1|
| 2|
| 3|
+-------+
Ahora vamos a repetir la sentencia INSERT ejecutada anteriormente, pero haremos un COMMIT
antes de perder la conexión al servidor al salir del monitor de MySQL.
mysql> BEGIN;
mysql> INSERT INTO innotest VALUES(4);
mysql> COMMIT;
mysql> EXIT;
Bye
Una vez que hacemos un COMMIT, la transacción es completada, y todas las sentencias SQL que
han sido ejecutadas previamente afectan de manera permanente a las tablas de la base de datos.
+-------+
| campo |
+-------+
| 1|
| 2|
| 3|
| 4|
+-------+
OTRO EJEMPLO
En el ejemplo anterior hemos usado únicamente sentencias INSERT, sin embargo, sucede lo mismo
con sentencias UPDATE o DELETE.
Vamos a crear una sencilla tabla llamada ventas que sea del tipo InnoDB.
CREATE TABLE ventas(
id INT NOT NULL PRIMARY KEY AUTO_INCREMENT,
producto VARCHAR(30) NOT NULL,
cantidad TINYINT NOT NULL) TYPE = InnoDB;
Insertamos un registro.
INSERT INTO ventas VALUES(0,'Gansito marinela',3);
mysql> SELECT * FROM ventas;
+----+------------------+----------+
| id | producto | cantidad |
+----+------------------+----------+
| 1 | Gansito marinela | 3 |
+----+------------------+----------+
1 row in set (0.01 sec)
Ahora vamos a iniciar una transacción con la sentencia BEGIN.

mysql> BEGIN;
Actualizamos el registro.
UPDATE ventas SET cantidad=4 WHERE id=1;
Verificamos que los cambios han sucedido.

+----+------------------+----------+
+----+------------------+----------+
+----+------------------+----------+
Si queremos deshacer los cambios, entonces ejecutamos un ROLLBACK.

mysql> ROLLBACK;
Verificamos que se deshicieron los cambios.

+----+------------------+----------+
+----+------------------+----------+
+----+------------------+----------+
Vamos a actualizar el registro usando otra transacción.

mysql> BEGIN;
mysql> UPDATE ventas SET cantidad=2 WHERE id=1;
+----+------------------+----------+
+----+------------------+----------+
+----+------------------+----------+
Vamos a confirmar que deseamos los cambios.
mysql> COMMIT;
En este momento los cambios son permanentes y definitivos.

+----+------------------+----------+
+----+------------------+----------+
+----+------------------+----------+
TAREA 13: Investigue como transformar tablas de con ingeniería MyISAM a InnoDB, utilice como
experimento una copia de la base de datos “Unidad”; desarrolle 3 ejercicios con instrucciones SQL
que permitan el uso de transacciones, justifique las propuestas.

TRIGGERS (Disparadores)
El soporte para TRIGGERS en MySQL se realizó a partir de la versión 5.0.2. Un trigger puede ser
definido para que se ejecute antes o después de un INSERT, DELETE o UPDATE en una tabla, lo hace
de forma automática por cada registro del query.
Los TRIGGERS en MySQL tienen la misma limitante que las funciones. No pueden acceder a una
tabla en general. Pueden solamente acceder a un valor del registro que está siendo modificado por
el query, es decir que se está ejecutando. Las características más importantes de los TRIGGERS son:
 Puede examinar el contenido actual de un renglón antes de que sea borrado o actualizado
 Puede examinar un nuevo valor para ser insertado o para actualizar un renglón de una tabla
 Un BEFORE TRIGGER, puede cambiar el nuevo valor antes de que sea almacenado en la base de
datos, lo que permite realizar un filtrado de la información.
Los triggers tienen dos palabras clave, OLD y NEW que se refieren a los valores que tienen las
columnas antes y después de la modificación. Los INSERT permiten NEW, los DELETE sólo OLD y los
UPDATE ambas.
El siguiente ejemplo muestra un ejemplo de TRIGGER que valida datos antes de ser guardados en la
tabla “Personas”:
DROP TRIGGER IF EXISTS valida_personas;
Delimiter //
CREATE TRIGGER valida_personas BEFORE INSERT ON Personas FOR EACH ROW
BEGIN
IF LENGTH(TRIM(NEW.apellidoPaterno))>0 THEN
SET NEW.ApellidoPaterno= UPPER(NEW.ApellidoPaterno);
ELSE
SET NEW.ApellidoPaterno="No Registrado";
END IF;
IF LENGTH(TRIM(NEW.apellidoMaterno))>0 THEN
SET NEW.ApellidoMaterno= UPPER(NEW.ApellidoMaterno);
ELSE
SET NEW.ApellidoMaterno="No Registrado";
END IF;
IF LENGTH(TRIM(NEW.Nombres))>0 THEN
SET NEW.Nombres= UPPER(NEW.Nombres);
ELSE
SET NEW.Nombres="No Registrado";
END IF;
IF LENGTH(TRIM(NEW.Direccion))>0 THEN
SET NEW.Direccion= UPPER(NEW.Direccion);
ELSE
SET NEW.Direccion="No Registrado";
END IF;
IF LENGTH(TRIM(NEW.Telefono))=0 THEN
SET NEW.Telefono="No Registrado";
END IF;
IF NEW.sexo<>'M' Or NEW.Sexo<>'F' THEN
SET NEW.sexo='M';
END IF;

IF NEW.estadocivil<>'S' Or NEW.EstadoCivil<>'C' Or NEW.EstadoCivil<>'D' Or NEW.EstadoCivil<>'V'

Or NEW.EstadoCivil<>'U' THEN
SET NEW.EstadoCivil='S';
END IF;
END//
Delimiter ;
El siguiente ejemplo agrega a la base de datos “Unidad” el proceso de monitorear a todos los
usuarios que acceden a ella, para esto se agregará la tabla “AuditoriaUsuarios”, ésta registrará cada
proceso que realice el usuario sobre la base de datos, como agregar nuevos registros, actualizarlos o
eliminarlos:
DROP TABLE IF EXISTS AuditoriaUsuarios;
CREATE TABLE AuditoriaUsuarios(
Id int NOT NULL AUTO_INCREMENT PRIMARY KEY,
Fecha datetime, -- fecha del proceso
Usuario varchar(40), -- usuario implicado
Proceso varchar(10), -- agregado, editado, eliminado
Datos varchar(255) NOT NULL -- observacion del proceso
);
El siguiente ejemplo de TRIGGER se ejecuta después de guardar datos sobre la tabla personas, esto
se lo puede aplicar a las otras tablas con las respectivas modificaciones:
DROP TRIGGER IF EXISTS MonitoreoPersonas;
Delimiter //
CREATE TRIGGER MonitoreoPersonas AFTER INSERT ON Personas FOR EACH ROW
BEGIN
DECLARE contenido Varchar(200);
SET contenido=CONCAT(NEW.IdPersona,' ',NEW.ApellidoPaterno,' ',NEW.ApellidoMaterno,'
',NEW.Nombres);
INSERT INTO AuditoriaUsuarios(Fecha,Usuario,Proceso,Datos)
VALUES (NOW(),USER(),'Agregado',contenido);
END //
Delimiter ;
El mismo monitoreo se realiza antes de actualizar datos sobre la table PERSONAS:

DROP TRIGGER IF EXISTS MonitoreoActualizacion;
DELIMITER //
CREATE TRIGGER MonitoreoActualizacion BEFORE UPDATE ON Personas FOR EACH ROW
BEGIN
DECLARE act varchar(200);
SET act=CONCAT(OLD.ApellidoPaterno,' por ',NEW.ApellidoPaterno,', ',OLD.ApellidoMaterno,' por
',NEW.ApellidoMaterno,', ',OLD.Nombres,' por ',NEW.Nombres);
SET act=CONCAT(act,', ', OLD.Direccion,' por ',NEW.Direccion,', ',OLD.Telefono,' por
',NEW.Telefono, ', ',OLD.Sexo,' por ',NEW.Sexo, ', ',OLD.EstadoCivil,' por ',NEW. EstadoCivil);
SET act=CONCAT(act,', ', OLD.FechaNacimiento,' por ',NEW.FechaNacimiento);
INSERT INTO AuditoriaUsuarios(Fecha,Usuario,Proceso,Datos) VALUES
(NOW(),USER(),'Actualizado',act);
END//
DELIMITER ;
TAREA 14: Considerando la base de datos que se utiliza en éste documento como ejemplo,
investigue y elabore un trigger que no permita, que un docente tenga más de 20 horas clase en el
periodo lectivo actual, justifique su propuesta.

GESTIÓN EN LA ADMINISTRACIÓN DE MYSQL
Existen muchas circunstancias en donde necesitaremos aplicar técnicas de mantenimiento y gestión

de la administración en una base de datos, el presente documento lo introduce en el tema y define
la aplicabilidad de los comandos en la gestión mediante el uso de la consola.
EXPORTACIÓN E IMPORTACION DE DATOS.
En algún momento necesitará generar un archivo con los resultados de un Query , para lograr esto
usted podría aplicar sentencia SELECT ... INTO OUTFILE, que produce la salida de la sentencia
SELECT a un fichero en lugar de hacerlo a la consola. La sintaxis de la parte INTO OUTFILE es:
[INTO OUTFILE 'file_name' export_options]
file_name es el nombre del fichero de salida, este nombre de fichero no debe existir en la ruta de
salida, ya que sí existe la sentencia fallará.
En cuanto a las opciones de exportación (export_options) son las que se utilizan en las cláusulas
FIELDS y LINES de LOAD DATA. Su sintaxis es:
[FIELDS
[TERMINATED BY '\t']
[[OPTIONALLY] ENCLOSED BY '']
[ESCAPED BY '\\' ]
]
[LINES
[STARTING BY '']
[TERMINATED BY '\n']
]
Estas cláusulas nos permiten crear diferentes formatos de archivos en la salida.

La cláusula FIELDS se refiere a las opciones de cada columna:
 TERMINATED BY 'carácter': nos permite definir el caracter delimitador que se usará para
separar cada columna. Por defecto el valor que se usa es el tabulador, pero podemos
cambiarlo por el punto y coma ';', o utilizar la coma ',', en realidad usted decide qué caracter
desea utilizar.
 [OPTIONALLY] ENCLOSED BY 'carácter': sirve para elegir el carácter usado para encerrar
cada columna. Por defecto no encierra ninguna columna, pero podemos elegir cualquier
caracter. Si se añade la palabra OPTIONALLY sólo se encerraran las columnas de tipo texto y
de tipo fecha.
 ESCAPED BY 'carácter': sirve para indicar el caracter que se usará para mostrar aquellos
caracteres que pueden dificultar la lectura posterior del fichero. Por ejemplo, si terminamos
las columnas con ',' y no las encerramos, un carácter ',' dentro de una columna de texto se
interpretará como un separador de columnas. Para evitar esto se puede mostrar esa coma
con otro carácter. Por defecto se usa el carácter '\'.
La cláusula LINES se refiere a las opciones para cada fila o cada registro:
 STARTING BY 'carácter': permite definir el carácter para comenzar cada línea. Por defecto
no se usa ningún carácter para ello.
 TERMINATED BY 'carácter': permite elegir el carácter para terminar cada línea. Por defecto
es el retorno de línea, pero se puede usar cualquier otro carácter o caracteres, por ejemplo
'\r\n'.

Por ejemplo, para obtener un archivo de texto a partir de la tabla ' Personas ', con las columnas
delimitadas por ';', encerrado las columnas de texto con '"' y separando cada fila por la secuencia
'\r\n', usaremos la siguiente instrucción:
SELECT * FROM Personas INTO OUTFILE "ListaPersonas.txt" FIELDS TERMINATED BY ';' OPTIONALLY
ENCLOSED BY '\"' LINES TERMINATED BY '\n\r';
Sí se desea cambiar el delimitador de columnas por la coma ‘,’ y el encerrado de columnas por el
apostrofe, entonces se ejecutaría lo siguiente:
SELECT * FROM Personas INTO OUTFILE "ListaPersonas.txt" FIELDS TERMINATED BY ',' OPTIONALLY
ENCLOSED BY '\’' LINES TERMINATED BY '\r';
También se puede crear un archivo de forma simple con la siguiente instrucción:

SELECT * FROM Personas INTO OUTFILE ‘ListaPersonas.txt’;
Por supuesto, el proceso contrario también es posible de realizar. Podemos leer el contenido de un
archivo de texto y vaciarlo a una tabla. El archivo origen puede haber sido creado mediante una
sentencia SELECT ... INTO OUTFILE, o mediante cualquier otro medio. Para hacerlo disponemos de
la sentencia LOAD DATA, cuya sintaxis más simple es:
LOAD DATA [LOCAL] INFILE 'Nombre_Archivo.txt'
[REPLACE | IGNORE]
INTO TABLE Nombre_Tabla
[FIELDS
[TERMINATED BY '\t']
[[OPTIONALLY] ENCLOSED BY '']
[ESCAPED BY '\\' ]
] [LINES
[STARTING BY '']
[TERMINATED BY '\n']
] [IGNORE number LINES]
[(Nombre_Campo,...)]
La cláusula LOCAL indica, si aparece, que el archivo está en el ordenador del cliente. Si no se
especifica el archivo de texto se buscará en el servidor, concretamente en el mismo directorio
donde esté la base de datos. Esto nos permite importar datos desde nuestro ordenador en un
sistema en que el servidor de MySQL se encuentra en otra máquina.
Las cláusulas REPLACE e IGNORE afectan al modo en que se tratan los registros leídos que
contengan el mismo valor para cada clave principal o única para cada registro existente en la tabla.
Si se especifica la cláusula REPLACE, este sustituirá el registro actual por el registro leído en el
archivo de texto. Si se especifica IGNORE el valor leído será ignorado y se registrará. La parte INTO
TABLA Nombre_Tabla indica en qué tabla se insertarán los valores leídos.
Las cláusulas FIELDS y LINES, su significado es el mismo que vimos para la sentencia SELECT ... INTO
OUTFILE. Estas sentencias nos permiten interpretar correctamente cada registro y cada campo,
adaptándonos al formato del archivo de texto de entrada.
La misma utilidad tiene la cláusula IGNORE número LINES, que nos permite que las primeras
número de líneas no se interpreten como datos a importar. Es frecuente que los ficheros de texto
que usaremos como fuente de datos contengan algunas cabeceras que expliquen el contenido del
fichero, o que contengan los nombres de cada campo. Usando esta cláusula podemos ignorarlas.

La última parte nos permite indicar el campo a la que será asignada cada una de las columnas
leídas, esto será útil si el orden de los campos en la tabla no es el mismo que en el fichero de texto,
o si el número de columnas es diferente en ambos.
Por ejemplo, supongamos que queremos añadir el contenido de este archivo a la tabla "Personas":
,Ureta,Parraga,Juan José,Cdla. Sur,052223256,M,1991-03-18,S
,Montenegro,Zambrano,Pascual,Cdla. Forestal,051123156,M,1999-04-23,S
,Espin,Almeida,Elva María,Rocafuerte,052636111,F,2001-10-20,S
,Intriago,Villa,Luis Francisco,Limón,052580113,M,1999-08-25,S
,Avila,Zamora,Eva María,Montecristi,052336232,F,2000-06-18,S
Como vemos, hay 9 columnas de datos, separados por 8 comas, en la tabla existen 9 campos, note
que cada fila empieza con una coma, esto se debe a que la tabla contiene como primer campo un
auto incrementable, por lo que quedará vacío, se lo hace, ya que el orden de las columnas es
importante.
La sentencia adecuada para leer los datos es
LOAD DATA INFILE "P-ListaPersonas.txt" INTO TABLE Personas FIELDS TERMINATED BY ',' LINES
TERMINATED BY '\n\r';
Qué pasaría si el contenido del archivo utiliza datos encerrados con apostrofes, para importar estos
datos usted debería utilizar el siguiente comando:
,'Vera','Paez','Juan José','Cdla. Norte','052553256','M','1989-03-18','V'
,'Mogro','Mera','Oscar','Cdla. Forestal','051166156','M','2000-04-23','D'
,'Pin','Almeida','María José','Mejía','052776111','F','2001-10-20','S'
,'Velez','Cano','Luis Francisco','Crucita','052880113','M','1989-08-25','C'
,'Pico','Pico','Eva María','Montecristi','052399232','F','1990-06-18','C'
LOAD DATA INFILE "P-ListaPersonas2.txt" INTO TABLE Personas FIELDS TERMINATED BY ','
OPTIONALLY ENCLOSED BY '\’' LINES TERMINATED BY '\n\r';
Suponiendo que el archivo de datos contiene títulos de cada columna, usted podría utilizar:
IdPersona, ApellidoPaterno, ApellidoMaterno, Nombres, Direccion, telefono, sexo,
FechaNacimiento, EstadoCivil
,Zuas,Parraga,Juan José,Cdla. Sur,052223256,M,1991-03-18,S
,Carbo,Zambrano,Pascual,Cdla. Norte,051123156,M,2000-04-23,S
,Vera,Almeida,Elva María,Manta,052636111,F,2001-10-20,S
,Macias,Villa,Luis Fercho,Jipijapa,052580113,M,1999-08-25,S
,Arauz,Zamora,Eva María,Santa Ana,052336232,F,2000-06-18,S
LOAD DATA INFILE "P-ListaPersonas3.txt" INTO TABLE Personas FIELDS TERMINATED BY ',' LINES
TERMINATED BY '\n\r'
IGNORE 0 LINES (IdPersona, ApellidoPaterno, ApellidoMaterno, Nombres, Direccion, telefono, sexo,
FechaNacimiento, EstadoCivil);
TAREA 15: El comité de padres de familia de la institución ha solicitado el listado de padres y

madres representantes por curso, La asociación de profesores ha solicitado el listado de profesores
que trabajarán en este periodo lectivo y el departamento de bienestar estudiantil ha solicitado el
listado de estudiantes matriculados en el presente periodo lectivo, Elabore los reportes en archivos
planos con el formato que usted considere adecuado, justifique cada propuestas.

ADMINISTRACIÓN DE CLAVES
Los Usuarios y permisos se guardan dentro de la base de datos principal del gestor de MYSQL, la
base de datos de llama mysql y las tablas utilizadas para registrarlos son USER y GRANT.
Se puede utilizar la instrucción UPDATE para cambiar la clave de acceso mediante el usuario root,
para ello se debe ingresar a la base de datos de MySQL y proceder a definir la clave:
mysql> USE mysql;
mysql> UPDATE user SET Password = PASSWORD('contraseña') WHERE User = 'root';
Sí usted desea quitar la clave simplemente contraseña debe estar vacía
Otra posibilidad sería:

mysql> SET password for root@localhost=PASSWORD('contraseña');
Sí desea cambiar la clave externamente podría utilizar el comando:

MYSQLADMIN -u root password PASSWORD_ELEGIDO
Una vez cambiada la clave es necesario indicar al servidor que vuelva a cargar las tablas de
privilegios:
mysql> FLUSH PRIVILEGES;
Usted puede ver las diferentes posibilidades de privilegios que pueden ser asignados a los
diferentes usuarios utilizando la orden:
SHOW PRIVILEGES;
Al aplicar esta orden le mostrará 3 columnas:

Privilege: Es el nombre del permiso.
Context: Contexto en el cual es posible aplicar el permiso
Comment: Breve explicación
Sí un usuario olvidó su clave, lo más recomendable es que usted se la elimine y después cuando
ingrese a su cuenta él la pueda cambiar, porque si intenta observar cual es la clave del usuario con
la instrucción SELECT en la tabla User lo más probable es que se decepcione, por ejemplo, aplique:
SELECT host, user, password FROM user;
Para cambiar la clave o quitarla a un supuesto usuario Miguel sería:

SET password FOR ‘miguel’@’localhost o IP’ = PASSWORD(‘CLAVE’);
El usuario puede crear su clave aplicando la siguiente instrucción:

SET password=PASSWORD(‘nueva_clave’);
TAREA 16: Investigue como desarrollar un control que permita registrar los usuarios con su
respectivo historial de claves utilizadas, Justifique su propuesta.

CHEQUEAR EL ESTADO DEL SERVIDOR
Sí necesitamos observar las estadísticas del uso del servidor, tendríamos que utilizar:
mysql> SHOW STATUS like 'com%';
Los servidores de base de datos de MySQL utilizan el espacio de memoria RAM disponible, para
establecer la cantidad de conexiones activas, para ver el número máximo de conexiones
simultaneas que su servidor soporta, se debe ejecutar la siguiente instrucción:
mysql> SHOW STATUS like ‘%connections%’;
Sí queremos chequear que el servidor mysql está activo, ejecutamos lo siguiente:

MYSQLADMIN -u root -p ping
Sí queremos chequear que versión de MySQL se está ejecutando

MYSQLADMIN -u root -p version
Ejecutando este comando, nos muestra el estado actual, uptime (tiempo encendido), threads (hilos
de procesos), y queries (cantidad de consultas).
MYSQLADMIN -u root -p status
Para chequear estos datos, ejecutamos lo siguiente.

MYSQLADMIN -u root -p extended-status
Para crear una base de datos nueva, ejecutamos.

MYSQLADMIN -u root -p create databasename
Ejecutando el siguiente comando podrá ser borrada, antes preguntara confirmación.

MYSQLADMIN -u root -p drop databasename
Este comando recarga los privilegios, reabre logs entre otros.

MYSQLADMIN -u root -p reload
MYSQLADMIN -u root -p refresh
Algunos comandos útiles para refrescar datos en MySQL

flush-hosts: Refresca toda la información del cache que hostea MySQL.
flush-tables: Refresca todas las tablas.
flush-threads: Refresca los hilos de ejecución.
flush-logs: Refresca todos los logs de información.
flush-privileges: Recarga las tablas de privilegios (lo mismo que recargar).
flush-status: Limpia el estado de las variables.
MYSQLADMIN -u root -p flush-hosts
MYSQLADMIN -u root -p flush-tables
MYSQLADMIN -u root -p flush-threads
MYSQLADMIN -u root -p flush-logs
MYSQLADMIN -u root -p flush-privileges
MYSQLADMIN -u root -p flush-status
Para matar un proceso cliente dormido, se ejecuta lo siguiente.

MYSQLADMIN -u root -p processlist
+----+------+-----------+----+---------+------+-------+------------------+
| Id | User | Host | db | Command | Time | State | Info |
+----+------+-----------+----+---------+------+-------+------------------+
| 5 | root | localhost | | Sleep | 14 | | |
| 8 | root | localhost | | Query | 0 | | show processlist |
+----+------+-----------+----+---------+------+-------+------------------+

Entonces ejecutamos el siguiente comando.

MYSQLADMIN -u root -p kill 5
+----+------+-----------+----+---------+------+-------+------------------+
| Id | User | Host | db | Command | Time | State | Info |
+----+------+-----------+----+---------+------+-------+------------------+
| 12 | root | localhost | | Query | 0 | | show processlist |
+----+------+-----------+----+---------+------+-------+------------------+
Si se necesita matar varios procesos, entonces le pasamos los ID's separados por comas.
MYSQLADMIN -u root -p kill 5,10
Para ejecutar varios comandos en una sola línea, se deberían verse de la siguiente manera.
MYSQLADMIN -u root -p processlist status version
Para ejecutar un comando en un servidor remoto, se utiliza la ip del servidor, por ejemplo para ver
el estado del servidor, usted puede utilizar.
MYSQLADMIN -h 172.16.25.126 -u root -p status
Sí usted necesita Iniciar/parar replica en un servidor remoto, utilizamos los siguientes comandos.
MYSQLADMIN -u root -p start-slave
MYSQLADMIN -u root -p stop-slave
Sí necesita apagar de forma segura el servidor:

MYSQLADMIN -u root -p shutdown
TAREA 17: Investigue almenos 2 utilidades prácticas que no se trataron en clase, que permita
evidenciar el uso de la herramienta, justifique lo investigado.
USO DE ENCRIPTACIONES
En algún momento usted necesitará proteger información clave como números de cuentas,
números de tarjetas de crédito, entre otros. Existen varias funciones que ofrecen diversos niveles
de seguridad, Estas funciones permiten el cifrado y descifrado de datos, usando algoritmos de
encriptación.
AES (Advanced Encryption Standard), conocido anteriormente como "Rijndael." Usa un cifrado con
una clave de 128-bit, pero puede ampliarlo hasta 256 bits modificando las fuentes; utilizaremos la
siguiente tabla para realizar pruebas de funcionamiento:
CREATE TABLE prueba(
ID int NOT NULL AUTO_INCREMENT,
NOMBRE VARCHAR(60) default NULL,
TAR_CREDITO VARCHAR(100),
PRIMARY KEY (id)
);
INSERT INTO prueba VALUES (1,'Gabriel Demera',AES_ENCRYPT('111-222-333-444-555','secret'));
INSERT INTO prueba VALUES (2,'Javier Moreno',AES_ENCRYPT('666-777-888-999-000','secret'));
En este ejemplo, el número de la tarjeta de crédito se almacena de forma encriptado, la palabra

‘secret’ que puede ser cualquier otro texto, actúa como llave, y es necesaria para desencriptar el
contenido del campo.
Para ver el contenido una vez encriptado escriba:

SELECT * FROM prueba;

Sí necesitamos ver los datos de forma normal tendríamos que aplicar:

SELECT id, nombre, AES_DECRYPT(TAR_CREDITO,'secret') FROM prueba;
Sí por algún motivo se le olvida la llave, los datos no podrán volverlos a recuperar, por ejemplo:
SELECT id, nombre, AES_DECRYPT(TAR_CREDITO,'otro') FROM prueba;
TAREA 18: Desarrolle una propuesta de base de datos, que permita utilizar la encriptación, realice
un ejemplo practico de su utilización, justifique la propuestas.
PARA ADMINISTRAR LOS RESPALDOS
Los procesos de respaldo son necesarios para salvaguardar la información almacenada en la base de
datos, existen muchas técnicas de respaldo o aseguramiento de que en caso de fallas del servidor o
del equipo se puede contar con la información hasta el momento de su respaldo.
Para guardar (exportar) la base de datos ejemplo “Unidad” se utiliza el comando MYSQLDUMP que
se encuentra en la carpeta de ejecución del servidor de MYSQL, para el caso de WAMP es:
C:\wamp\bin\mysql\mysql5.1.36\bin>
El siguiente ejemplo respalda la información contenida en la base de datos Unidad y genera un

archivo llamado backup.sql:
MYSQLDUMP --opt --user=root Unidad > backup.sql
Normalmente, una base de datos no solo contiene vistas, tablas y sus registros, sino que contiene
procedimientos almacenados y otras codificaciones necesarias para la gestión de los datos, para
incluirlos en el respaldo usted debe aplicar la instrucción de la siguiente forma:
MYSQLDUMP -u root -p Unidad --routines > backup_con_procedures.sql
Ahora sí usted solo necesita los procedimientos almacenados, funciones y triggers, y no los datos,
entonces puede hacer uso de:
MYSQLDUMP -u root --routines --no-create-info --no-data --no-create-db --skip-opt Unidad >
OtroRespaldo.sql
PARA IMPORTAR O RESTAURAR UN RESPALDO

El proceso de restauración se constituye, como un proceso en el que se copia los datos guardados
en el archivo de respaldo, y reemplazarlos por los datos que se encuentran en la base de datos,
usted se verá obligado a realizar esto cuando ocurra un daño sobre la base de datos, como por
ejemplo eliminaciones o actualizaciones involuntarias; o también cuando ocurra un error en el disco
duro o en dispositivos de comunicación relacionado con la base de datos.
Para realizar este proceso usted debe ubicar el archivo de respaldo backup.sql en la carpeta de
ejecución del servidor, para el caso de práctica: C:\wamp\bin\mysql\mysql5.1.36\bin>
Sí la base de datos no está creada se la debe crear primero, para ello Ud. Debe ingresar a la consola
y crearla:
mysql -u root
CREATE DATABASE Unidad;

Una vez creada la base de datos Ud. debe salir de la consola “mysql> quit;” y escribir la siguiente
orden:
C:\wamp\bin\mysql\mysql5.1.36\bin>mysql --user=root –p Unidad < backup.sql
Otra posibilidad es desde la consola de mysql mediante la orden SOURCE, que utiliza un formato
como “mysql> SOURCE /ruta/archivo.sql”, por ejemplo:
mysql> SOURCE backup.sql;
TAREA 19: Desarrolle una practica de respaldo y restauración de una base de datos, considere el
caso de que se han borrado registros de la base de datos original, restaure y describa su experiencia
al realizar la práctica, investigue y proponga sus normas o políticas de respaldo y aseguramiento de
la información.
REPLICACIONES
Los sistemas de gestión de las bases de datos, ofrece la capacidad de acceder a la información
desde cualquier punto geográfico, siempre que los sistemas de comunicación y de seguridad asi lo
permitan, básicamente gestionan mediante el modelo cliente-servidor. Esta posibilidad obliga a que
la gestión y la estructura de la base de datos tengan gran importancia de manera que los servicios
que ofrecen funciones de manera continua.
La replicación es una herramienta que permite distribuir datos en servidores separados, con el
objetivo de trabajar con los mismos datos pero en recursos físicos diferentes, esto permite reducir
la dependencia de un sistema de base de datos centralizado.
Para garantizar que una aplicación distribuida este confiadamente disponible, se deben instanciar
múltiples réplicas de ésta, en distintos ordenadores. Se debe conseguir que cada uno de los
ordenadores que mantenga una réplica de la base de datos sea independiente de los demás, esto
por la probabilidad de la ocurrencia de fallos.
El objetivo principal para la distribución de datos es proveer un acceso sencillo a la información por
parte de los usuarios de múltiples localidades o nodos de trabajo de una red de computadoras. Es
decir que una de las fortalezas de la herramienta radica en aumentar la disponibilidad de la
información aumentando el paralelismo en las consultas, ya que la misma información esta
almacenada en más de una localidad de la red y mejorar la disponibilidad de los datos ante
eventuales caídas de servidores de la red.
Para demostrar la funcionalidad de la replicación se explicará el proceso de configuración entre dos

equipos (HOST), uno de ellos se denominará PC-MASTER, es considerado como el equipo principal
de la replicación, la funcionalidad de éste servidor radica en receptar los procesos de agregado,
actualizado y eliminado de los datos, para que el equipo PC-ESCLAVO lo replique de forma
automática, convirtiéndose prácticamente en un espejo del principal, convirtiendo al PC-ESCLAVO
en el servidor que atenderá los procesos de consulta, liberando a PC-MASTER de dicha carga de
trabajo, la práctica de configuración del software se lo desarrollará en paquete de desarrollo
WAMP, asumiendo que su equipo dispone de una máquina virtual instalada para simular el uso de
otro equipo:

1. Sí usted desconoce la administración de los escudos de Antivirus y del Firewall de Windows

en la máquina real y en la máquina virtual, se le recomienda desactivarlos para evitar
inconvenientes en el desarrollo de la misma.
2. Asumiendo que se está utilizando la máquina virtual (MV) de Virtual Box, en la configuración
de red del sistema operativo que esté utilizando en este caso XP, seleccione el adaptador,
escoja la opción adaptador puente y más abajo seleccione la tarjeta de red que utilizare, en
este caso se escoge el adaptador de la red LAN. Si está utilizando conexión WAN debería
escoger el adaptador Wireless. Seguido de esto se da clic en aceptar, aquí una gráfica
ejemplo:
3. Considere la siguiente dirección IP para configurar la red en la PC-MASTER
4. Utilice las siguiente dirección IP para configurar el PC-ESCLAVO (La Máquina Virtual)
5. Verifique si las dos máquinas están conectadas, esto mediante el protocolo ICMP haciendo
ping de una maquina a otra.
De la PC-Master a la PC-Esclavo

De la PC-Esclavo a la PC-Master
6. MySQL posee un archivo de configuración llamado My.ini que define el comportamiento del
servidor, usted necesita editarlo y después verificar que no estén comentadas (es decir no
estén precedidas por el signo numeral #) las siguientes líneas, Para PC-MASTER:
log-bin=mysql-bin
server-id=1
Observe la siguiente gráfica:
Para PC-ESCLAVO cambio la línea:

server-id=1 por server-id=2
7. Reinicie el servicio “wampmysqld” en cada una de las PC, para esto seleccione:
Panel de Control\Herramientas Administrativas\Servicios, busque el servicio “wampmysqld”,
selecciónelo y haga clic en la opción Reiniciar el servicio.
Considere la siguiente gráfica:

8. Una vez establecida la comunicación y reiniciados los cambios en la configuración de los

servidores, usted debe entrar a la consola de MySql y hacer los siguientes pasos:
a. Crear un usuario de replicación en el PC-MASTER para que el servidor de PC-
ESCLAVO pueda acceder y replicar:
GRANT REPLICATION SLAVE ON *.* TO ‘esclavo’@’192.168.1.3’ IDENTIFIED BY ‘123’;
b. Ejecute el comando (FLUSH PRIVILEGES;) para actualizar los privilegios de los
usuarios en el servidor de PC-MASTER.
c. Ahora necesitará realizar una copia exacta de la base de datos a replicar, para esto es
necesario bloquearla con el comando:
FLUSH TABLES WITH READ LOCK;
d. El gestor de base de datos genera un archivo de conexión (log bin) con el servidor
principal, es necesario conocer el nombre del mismo para que el servidor a replicar
establezca conexión, para mostrar el nombre y su número de posición se utiliza el
comando (MASTER STATUS;)
Para el ejemplo el archivo se llama mysql-bin.000014 y su posición en 545, esto

cambiará dependiendo del servidor, concluido esto se sale de la terminal de MySQL.
9. Ahora se creará una copia de respaldo de la base de datos a replicar, para esto se utilizará el
siguiente comando fuera de la consola de MYSQL:
C:\wamp\bin\mysql ….\bin>MYSQLDUMP –u root –p Unidad > replicaUnidad.sql
10. Nuevamente se debe entrar a la terminal de MySQL y aplicar el desbloqueo con el comando:
UNLOCK TABLES;
Para el ejemplo, es todo lo que hay que realizar en el servidor de PC-MASTER, los siguientes pasos
son para configurar la consola MySQL de la PC-ESCLAVO
11. Lo siguiente es ingresar a la consola de PC-ESCLAVO y crear una nueva base de datos con el
mismo nombre de la base de datos que tiene el PC-MAESTRO a la cual se le está trabajando
la réplica:
CREATE DATABASE Unidad;
12. Salga de la terminal (\q) y proceda a restaurar las tablas que respaldamos en el PC_MASTER
con el siguiente comando:
MYSQL –u root –p Unidad < replicaUnidad.sql
13. Se debe entrar nuevamente a la terminal de MySQL y parar los servicios del esclavo con el
siguiente comando:
STOP SLAVE;
14. Configure la conexión con el PC-MASTER con el siguiente comando:
CHANGE MASTER TO master_host=’192.168.1.2’,
master_user=’esclavo’,
master_password=’123’,
master_log_file=’mysql-bin.000014’,
master_log_pos=545;
15. Una vez configurado el servidor, inicie los servicios del esclavo con el comando:
START SLAVE;

16. Para comprobar que hay replica escribimos el siguiente comando que nos dirá si está o no
funcionando:
SHOW SLAVE STATUS \G;
Sí “Seconds_Behind_Master” muestra un 0 es porque está funcionando correctamente de lo contrario

mostrara un Null.
Para ver el funcionamiento de los servidores replicados, es necesario que agregue o actualice un
registro en la base de datos del PC_MASTER y pueda observar su cambio en PC-ESCLAVO.
TAREA 20: Desarrolle una práctica con almenos 3 estudiantes incluyéndose, sobre replicación de
una base de datos con almenos 2 servidores esclavos y un servidor master, desarrolle un ensayo
sobre la realización de la misma, (Adjuntar evidencia de que trabajaron los integrantes).

PARA ADMINISTRAR EL ESTADO DE LAS TABLAS
Los sistemas de gestión de base de datos poseen instrucciones qué permiten el mantenimiento de
sus estructuras de tablas, por ejemplo: ANALYZE TABLE, analiza y almacena la distribución de claves
para una tabla. Durante el análisis, la tabla se bloquea con un bloqueo de lectura para InnoDB y
MyISAM.
Una de las razones para emitir ANALYZE TABLE es cuando tenemos un montón de modificación de
una tabla (INSERT o DELETE, por ejemplo), con el tiempo el optimizador no puede hacer la mejor
elección cuando se trata de decidir si debe utilizar un índice específico o no. Al ejecutar ANALYZE
TABLE, podemos ayudar a que gestione de forma correcta. ANALYZE ayuda al optimizador de
consultas para hacer decisiones exactas por un análisis detallado de los datos, a diferencia de
optimizador de consultas que hace un análisis rápido. Para evitar la degradación del rendimiento
resulta de vital importancia analizar y optimizar las tablas periódicamente, sobre todo si el número
de registros varía frecuentemente. Para ello debemos utilizar los comandos ANALYZE TABLE y
OPTIMIZE TABLE:
ANALYZE TABLE Personas;
OPTIMIZE TABLE Personas;
OPTIMIZE TABLE
OPTIMIZE [LOCAL | NO_WRITE_TO_BINLOG] TABLE tbl_name [, tbl_name] ...
OPTIMIZE TABLE debe usarse si ha borrado una gran parte de la tabla o si ha hecho varios cambios
en una tabla con registros de longitud variable (tablas que tienen columnas VARCHAR, BLOB, o TEXT
). Los registros borrados se mantienen en una lista enlazada y operaciones INSERT posteriores
reúsan posiciones de antiguos registros. Puede utilizar OPTIMIZE TABLE para reclamar la
disponibilidad no usada y para desfragmentar el fichero de datos.
En la mayoría de inicializaciones, no necesita ejecutar OPTIMIZE TABLE para nada. Incluso si hace
muchas actualizaciones a registros de longitud variables, no es probable que necesite hacerlo más
de una vez a la semana o mes y sólo en ciertas tablas.
Actualmente, OPTIMIZE TABLE funciona sólo en tablas MyISAM, BDB y InnoDB .
Para tablas MyISAM , OPTIMIZE TABLE funciona como sigue:

1. Si la tabla ha borrado o dividido registros, repare la tabla.
2. Si las páginas de índice no están ordenadas, ordénelas.
3. Si las estadísticas no están actualizadas (y la reparación no puede hacerse ordenando el índice),
actualícelas.
Para tablas InnoDB , se mapea con ALTER TABLE, que reconstruye la tabla. Reconstruye las
estadísticas actualizadas de índice y libera espacio no usado en el índice clusterizado.
Puede hacer que OPTIMIZE TABLE funcione con otros tipos de tabla arrancando mysqld con la
opción --skip-new o --safe-mode ; en este caso OPTIMIZE TABLE se mapea con ALTER TABLE.
Tenga en cuenta que MySQL bloquea la tabla mientras se ejecuta OPTIMIZE TABLE.

PERROR
Cuando se trabajan con tablas se pueden presentar errores e índices corruptos, los síntomas de
tablas corruptas incluyen consultas que abortan inesperadamente y errores observables como los
siguientes:
 tbl_name.frm is locked against change
 Can't find file tbl_name.MYI (Errcode: ###)
 Unexpected end of file
 Record file is crashed
 Got error ### from table handler
Para obtener una descripción acerca de los errores puede ejectuar PERROR ###, donde ### es el
número de error. El siguiente ejemplo muestra cómo usar PERROR para encontrar el significado de
la mayoría de errores comunes que indican un problema con la tabla:
C:\wamp\bin\mysql\mysql5.1.36\bin>PERROR 126 127 132 134 135 136 141 144 145
MySQL error code 126: Index file is crashed
Win32 error code 126: No se puede encontrar el módulo especificado.
MySQL error code 127: Record file is crashed
Win32 error code 127: No se encontró el proceso especificado.
MySQL error code 132: Old database file
Win32 error code 132: El puntero del archivo no puede establecerse en el dispositivo especificado.
MySQL error code 134: Record was already deleted (or record file crashed)
Win32 error code 134: Se ha intentado utilizar JOIN o SUBST en una unidad que ya se había unido.
MySQL error code 135: No more room in record file
Win32 error code 135: Se ha intentado utilizar JOIN o SUBST en una unidad que se había sustituido.
MySQL error code 136: No more room in index file
Win32 error code 136: El sistema ha intentado eliminar la unión de una unidad que no está unida.
MySQL error code 141: Duplicate unique key or constraint on write or update
Win32 error code 141: El sistema ha intentado sustituir una unidad por un directorio unidad.
MySQL error code 144: Table is crashed and last repair failed
Win32 error code 144: El directorio no es un subdirectorio del directorio raíz.
MySQL error code 145: Table was marked as crashed and should be repaired
Win32 error code 145: El directorio no está vacío.
Primero se procede a verificar la tabla, para determinar el problema:

mysql> CHECK TABLE Personas;
CHECK TABLE
CHECK TABLE tbl_name [, tbl_name] ... [option] ...
option = {QUICK | FAST | MEDIUM | EXTENDED | CHANGED}
Chequea una o varias tablas para errores. CHECK TABLE funciona para tablas MyISAM y InnoDB . Para
tablas MyISAM , la estadística de clave se actualiza.
Desde MySQL 5.0.2, CHECK TABLE puede comprobar las vistas en busca de problemas tales como
tablas que se referencian en la definición de la vista que ya no existe.
El comando CHECK TABLE retorna un cuadro con las siguientes columnas:

TABLA NOMBRE DE TABLA

Op Siempre con el contenido check
COLUMNA VALOR
Msg_type Es status, error, info, o warning
Msg_text Mensaje de descripción
Tenga en cuenta que el comando puede producir varios registros para información de cada tabla
chequeada. El último registro tiene un valor Msg_type de status y Msg_text normalmente debe ser
OK. Si no obtiene OK, o Table is already up to date (significa que el motor de almacenamiento para
la tabla indicada no hay necesidad de chequear la tabla) debe realizar una reparación de la tabla.
Se puede dar el caso de que algunos problemas reportados por CHECK TABLE no puedan corregirse
automáticamente por ejemplo “Found row where the auto_increment column has the value 0”,
esto significa que tiene un registro en la tabla donde la columna AUTO_INCREMENT contiene un
valor de índice 0. (Esto puede ser posible al utilizar un comando UPDATE errado), en sí no es un
error por sí mismo, pero puede causar problemas si decide volcar la tabla y restaurarla o realizar un
ALTER TABLE en la tabla. En este caso, la columna AUTO_INCREMENT cambia los valores según las
reglas de las columnas AUTO_INCREMENT , que pueden causar problemas tales como errores de
clave duplicada. Para evitar las advertencias, simplemente ejecute un comando UPDATE para poner
en la columna un valor distinto a 0.
Se pueden presentar problemas como tablas no cerradas adecuadamente o índices corruptos, por
ejemplo cuando ocurre de un apagón. Ahora para reparar la tabla se puede usar la siguiente
sentencia:
mysql> REPAIR TABLE Personas;
REPAIR TABLE
REPAIR [LOCAL | NO_WRITE_TO_BINLOG] TABLE
tbl_name [, tbl_name] ... [QUICK] [EXTENDED] [USE_FRM]
REPAIR TABLE repara una tabla posiblemente corrupta. Por defecto, tiene el mismo efecto que
myisamchk --recover tbl_name. REPAIR TABLE funciona sólo en tablas MyISAM.
Normalmente nunca debe ejecutar este comando. Sin embargo, si hay un desastre, REPAIR TABLE
puede recuperar todos los datos de una tabla MyISAM . Si sus tablas se corrompen a menudo, debe
intentar encontrar la razón de lo que lo causa, para eliminar la necesidad de usar REPAIR TABLE.
El comando retorna una tabla con las siguientes columnas:
COLUMNA VALOR
Tabla Nombre de tabla
Op Siempre es repair
Msg_type Es status, error, info, o
warning
Msg_text Mensaje
El comando REPAIR TABLE puede producir muchos registros de información para cada tabla
reparada. El último registro tiene un valor Msg_type de status y Msg_test normalmente debe ser

OK. Si no obtiene OK, debe intentar reparar la tabla con myisamchk --safe-recover, ya que REPAIR
TABLE no implementa todas las opciones de myisamchk.
PARA ADMINISTRAR EL ESTADO DE LAS BASE DE DATOS
MYSQLCHECK comprueba y repara tablas MyISAM. También puede optimizar y analizar tablas.
MYSQLCHECK es similar a MYISAMCHK, pero funciona de forma distinta. La principal diferencia

operacional es que mysqlcheck debe usarse cuando el servidor mysqld está en ejecución, mientras
que myisamchk debe usarse cuando no lo está. El beneficio de usar mysqlcheck es que no tiene que
parar el servidor para comprobar o reparar las tablas.
MYSQLCHECK usa los comandos SQL CHECK TABLE, REPAIR TABLE, ANALYZE TABLE, y OPTIMIZE
TABLE de forma conveniente para los usuarios. Determina los comandos a usar en función de la
operación que quiera realizar, luego envía los comandos al servidor para ejecutarlos. Hay tres
modos generales de invocar mysqlcheck:
shell> mysqlcheck [opciones] nombre_de_base_de_datos [tablas]
shell> mysqlcheck [opciones] --databases DB1 [DB2 DB3...]
shell> mysqlcheck [opciones] --all-databases
Si no nombra ninguna tabla o usa las opciones --databases o --all-databases, se comprueban todas
las bases de datos.
MYSQLCHECK tiene una característica especial comparada con otros clientes. El comportamiento
por defecto de comprobar tablas (--check). Si quiere tener una herramienta que repare las tablas
por defecto, debe hacer una copia de mysqlcheck llamada MYSQLREPAIR, o hacer un enlace
simbólico a mysqlcheck llamado mysqlrepair. Si invoca mysqlrepair, repara tablas.
Los siguientes nombres pueden usarse para cambiar el comportamiento por defecto de
mysqlcheck:
MYSQLREPAIR La opción por defecto es --repair

MYSQLANALYZE La opción por defecto es --analyze
MYSQLOPTIMIZE La opción por defecto es --optimize
Ejemplos:
C:\wamp\bin\mysql\mysql5.1.36\bin> mysqlcheck -u root –repair Unidad
C:\wamp\bin\mysql\mysql5.1.36\bin> mysqlcheck -u root –analyze Unidad
C:\wamp\bin\mysql\mysql5.1.36\bin>mysqlcheck -u root –optimize Unidad
MYSQLCHECK soporta las siguientes opciones:

--help, -? Muestra el mensaje de ayuda y sale.
--all-databases, -A Comprueba todas las tablas en todas las bases de datos. Esto es lo mismo que usar la
opción --databases y llamar todas las bases de datos en la línea de comandos.
--all-in-1, -1 En lugar de realizar un comando para cada tabla, ejecuta un único comando para cada base de
datos, que nombra todas las tablas de la base de datos a procesar.
--analyze, -a Analiza las tablas.
--auto-repair Si una tabla comprobada está corrupta, la repara automáticamente. Cualquier reparación
necesaria se hace tras el chequeo de cada tabla.
--character-sets-dir=path El directorio donde los conjuntos de caracteres están instalados.
--check, -c Comprueba las tablas en busca de errores.

--check-only-changed, -C Chequea sólo tablas que han cambiado desde la última comprobación o que no se
han cerrado correctamente.
--compress Comprime toda la información enviada entre el cliente y el servidor si ambos soportan
compresión.
--databases, -B Procesa todas las tablas en la base de datos especificada. Con esta opción, todos los
argumentos nombrados se tratan como nombres de bases de datos, no como nombres de tablas.
--debug[=opciones_de_depuración], -# [opciones_de_depuración] Escribe un log de depuración. La cadena
de caracteres opciones_de_depuración a menudo es 'd:t:o,nombre_de_fichero'.
--default-character-set=conjunto_de_caracteres Usa conjunto_de_caracteres como el conjunto de
caracteres por defecto.
--extended, -e Si usa esta opción para comprobar tablas, se asegura que sean 100% consistentes pero tarda
bastante. Si usa esta opción para reparar tablas, ejecuta una reparación extendida que puede no sólo tardar
bastante tiempo, sino que ¡también puede producir un montón de registros basura!
--fast, -F Comprueba sólo tablas que no se han cerrado correctamente.
--force, -f Continúa incluso si se produce un error SQL.
--host=nombre_de_equipo, -h nombre_de_equipo Conecta con el servidor MySQL en el equipo dado.
--medium-check, -m Realiza un chequeo que es más rápido que la operación --extended. Esto encuentra
sólo el 99.99% de todos los errores, lo cual debería ser suficiente en la mayoría de casos.
--optimize, -o Optimiza las tablas.
--password[=contraseña], -p[contraseña] La contraseña a usar cuando se conecta con el servidor. Si usa la
opción con su forma corta (-p), no puede haber un espacio entre la opción y la contraseña. Si omite el valor
contraseña a continuación de la opción --password o -p en la línea de comandos, aparece un prompt
pidiéndola.
--port=número_de_puerto, -P número_de_puerto El puerto TCP/IP para usar en la conexión.
--protocol={TCP | SOCKET | PIPE | MEMORY} Protocolo de conexión a usar.
--quick, -q Si usa esta opción para comprobar tablas, evita que el chequeo escanee los registros para buscar
enlaces incorrectos; es el método de chequeo más rápido. Si se utiliza esta opción para reparar tablas, el
programa intenta reparar sólo el árbol del índice. Este es el método más rápido de reparación.
--repair, -r Hace una reparación que puede arreglar prácticamente todo excepto claves únicas que no son
únicas.
--silent, -s Modo silencioso. Sólo muestra mensajes de error.
--socket=ruta, -S ruta Fichero socket a usar en la conexión.
--tables Más prioritaria que la opción --databases o -B. Todos los argumentos que vienen después de la
opción se consideran nombres de tablas.
--user=nombre_de_usuario, -u nombre_de_usuario El nombre de usuario MySQL a usar cuando se conecta
al servidor.
--verbose, -v Modo explícito. Muestra información acerca de varios estados de las operaciones del
programa.
--version, -V Muestra información de la versión y sale.
La forma más simple se uso es:

C:\wamp\bin\mysql\mysql5.1.36\bin>MYSQLCHECK -u root Unidad
Entre las opciones más utilizadas están:

Reparar & Optimizar:
MYSQLCHECK -Aor
Sólo Reparar:
MYSQLCHECK -Ar
Sólo Optimizar:
MYSQLCHECK –Ao

ARCHIVOS DE BASE DE DATOS

MySQL es modular, permite elegir entre diferentes engine para el almacenamiento de datos,
MySQL posee varios engine, estos definen el soporte a nivel de tablas y no de base de datos, una
base de datos puede tener varios engine entre sus tablas, MyISAM es una engine por defecto de
MySQL, éstas engine posee tablas definidas por tres ficheros: MiTabla.frm, MiTabla.MYD,
MiTabla.MYI.
Para ver las engine que soporta su servidor de base de datos se aplica la orden:
mysql> SHOW ENGINES \G
MYISAMCHK
myisamchk C:\wamp\bin\mysql\mysql5.1.36\Data\BaseDatos\*.MYI
myisamchk C:\wamp\bin\mysql\mysql5.1.36\Data\BaseDatos\tabla.MYI
El programa myisamchk es una utilidad en línea de comandos que se incluye con la distribución de
MySQL y sirve para reparar tablas tipo MyISAM. Para utilizarlo con seguridad el servidor no debe
estar ejecutándose y se recomienda realizar un respaldo del directorio de datos antes de su
utilización.
Recibe como parámetro principal los archivos .MYI correspondientes a las tablas que hay que
revisar; es decir, myisamchk no conoce la ubicación del directorio de datos por lo que el ejemplo
inicial lo describe, asumiendo que se lo utiliza bajo la plataforma de Windows.
Por otro lado, si el directorio de datos está ubicado bajo la plataforma de Linux en /val/lib/mysql,
las siguientes serían dos maneras de realizar una comprobación de los archivos de la base de datos:
myisamchk /var/lib/mysql/BaseDatos/*.MYI
cd /var/lib/lib/mysql/BaseDatos
myisamchk *.MYI
Se pueden revisar todas las bases de datos utilizando ’*’ para denominar el directorio de la base de
datos:
myisamchk /var/lib/mysql/*/*.MYI
Para realizar una comprobación rápida, el manual sugiere utilizar el siguiente comando:
SHELL> myisamchk --silent --fast *.MYI
Y para realizar la corrección de las tablas corruptas, el manual sugiere la sintaxis siguiente:
SHELL> myisamchk --silent --force --update-state -O key_buffer=64M \
-O sort_buffer=64M -O read_buffer=1M -O write_buffer=1M *.MYI
TAREA 21: Investigue 1 casos de rescate y recuperación de base de datos que se haya presentado,
describa con su palabra que opina sobre el hecho presentado.

ADMINISTRACIÓN DE LA EFICIENCIA DE UNA SENTENCIA SELECT
EXPLAIN
EXPLAIN nombre_de_tabla
O:
EXPLAIN SELECT opciones_de_select
La sentencia EXPLAIN puede utilizarse como un sinónimo de DESCRIBE o también como una manera
para obtener información acerca de cómo MySQL ejecuta una sentencia SELECT:
 EXPLAIN nombre_de_tabla es sinónimo de DESCRIBE nombre_de_tabla o SHOW COLUMNS

FROM nombre_de_tabla.
 Cuando se precede una sentencia SELECT con la palabra EXPLAIN, MySQL muestra información
del optimizador sobre el plan de ejecución de la sentencia. Es decir, MySQL explica cómo
procesaría el SELECT, proporcionando también información acerca de cómo y en qué orden
están unidas (join) las tablas.
EXPLAIN es una ayuda para decidir qué índices agregar a las tablas, con el fin de que las sentencias
SELECT encuentren registros más rápidamente. EXPLAIN puede utilizarse también para verificar si el
optimizador une (join) las tablas en el orden óptimo. Si no fuera así, se puede forzar al optimizador
a unir las tablas en el orden en el que se especifican en la sentencia SELECT empezando la sentencia
con SELECT STRAIGHT_JOIN en vez de simplemente SELECT.
Si un índice no está siendo utilizado por las sentencias SELECT cuando debiera, debe ejecutarse el
comando ANALYZE TABLE, a fin de actualizar las estadísticas de la tabla como la cardinalidad de sus
claves, que pueden afectar a las decisiones que el optimizador toma.
EXPLAIN muestra una línea de información para cada tabla utilizada en la sentencia SELECT. Las
tablas se muestran en el mismo orden en el que MySQL las leería al procesar la consulta. MySQL
resuelve todas las uniones (joins) usando un método de single-sweep multi-join. Esto significa que
MySQL lee un registro de la primera tabla; encuentra su correspondiente en la segunda tabla, en la
tercera, y así sucesivamente. Cuando todas las tablas han sido procesadas, MySQL muestra las
columnas seleccionadas y recorre a la inversa la lista de tablas hasta que encuentra aquélla para la
que la sentencia devuelve más registros. Se lee entonces el siguiente registro de esta tabla y el
proceso continúa con la siguiente tabla.
Pero, ¿Qué quieren decir estas columnas? ¿Qué información nos dan?
1. Table: Nos informa de la tabla a la que nos estamos refiriendo.

2. Type: El tipo de unión que se está usando. Desde la mejor hasta la peor, los tipos de uniones son
system, const, eq_ref, ref, range, index, y ALL.
 System: Tabla con una única fila, por tanto, la respuesta es inmediata.
 Const: En la tabla coincide una única fila con los criterios indicados. Al sólo haber una fila, el
optimizador toma este valor como constante, por este motivo este tipo de tablas son muy
rápidas.
 Eq_ref: Una fila de la tabla 1 será leída por cada combinación de filas de la tabla 2. Este tipo
es usado cuando todas las partes de un índice se usan en la consulta y el índice es UNIQUE o
PRIMARY KEY.

 Ref: Todas las filas con valores en el índice que coincidan serán leídos desde esta tabla por
cada combinación de filas de las tablas previas. Similar a eq_ref, pero usado cuando usa sólo
un prefijo más a la izquierda de la clave o si la clave no es UNIQUE o PRIMARY KEY. Si la clave
que es usada coincide sólo con pocas filas, esta union es buena.
 Range: Sólo serán recuperadas las filas que estén en un rango dado, usando un índice para
seleccionar las filas. La columna key indica cual índice es usado, y el valor key_len contiene
la parte más grande de la clave que fue usada. La columna ref será NULL para este tipo.
 Index: Escaneo completo de la tabla para cada combinación de filas de las tablas previas,
revisando únicamente el índice.
 ALL: Escaneo completo de la tabla para cada combinación de filas. Es el peor caso ya que
revisará todas las filas para cada combinación.
3. Possible_keys: Posibles indices que utilizará la consulta.

4. Key: Índice utilizado para ejecutar la consulta. Si indica el valor NULL, no se ha escogido ningún
índice.
5. Key_len: Cuanto más pequeño sea este valor, más rápida será la consulta, pues nos indica la
longitud del índice usado.
6. Ref: Las columnas del índice que se está usando, o una constante si esta es posible.
7. Rows: Número de filas que MySQL debe analizar para devolver los datos solicitados.
8. Extra: Información complementaria sobre como MySQL ejecutará la consulta. Los posibles
valores en este campo pueden ser:
 Distinct: MySQL ha encontrado una fila coincidente con los filtros indicados y no necesita
seguir analizando.
 Not exists: MySQL fue capaz de hacer una optimización LEFT JOIN sobre la consulta y no
examinará más filas en la tabla para la combinación de filas previa después de que
encuentre una fila que coincida con el criterio LEFT JOIN.
 Range checked for each record: No se encontró un índice válido. Para cada combinación de
filas se hará un chequeo para determinar que indice utilizar y en caso de encontrar alguno
válido, lo utilizará.
 Using filesort: Este valor indica que MySQL necesita hacer un paso extra para encontrar la
forma de ordenar las filas. Este tipo de consultas debe ser optimizada.
 Using index: Recupera la información solicitada utilizando únicamente la información del
índice. Esto sucede cuando todas las columnas requeridas forman parte del índice.
 Using temporary: Para resolver esta consulta, MySQL creará una tabla temporal. Uno de los
casos típicos en los que devuelve este valor es cuando usamos un ORDER BY sobre un
conjunto de columnas diferentes a las indicadas en la clausula GROUP BY. Este tipo de
consultas debe ser optimizada.
 Where used: Se usará una clausula WHERE para determinar que filas serán comparadas con
otra tabla. Si no deseamos regresar todas las filas desde la tabla, y el join es del tipo ALL o
index, es muy probable que hayamos escrito algo mal en la consulta.
Una respuesta en este campo del tipo “Using filesort” o “Using temporary” es susceptible de
ser una consulta a optimizar.
Si analizamos la consulta ejecutada anteriormente, vemos que para la tabla con alias ‘up’ está
utilizando el tipo de unión ÀLL` debido a que no existe ningún filtro en la cláusula WHERE (en este
caso, es normal ya que queremos devolver todos los valores). Se podría utilizar el índice existente

ùser_id_idx` pero al no haber ningún filtro, no es necesario usarlo. Para devolver esta consulta
MySQL analizará 13 filas.
La segunda fila hace referencia a la tabla con alias ‘u’. Utiliza un tipo de unión èq_ref` ya que
devolverá una fila para cada fila de la tabla ùp` pudiendo usar y usando el índice primario de la
tabla que tiene una longitud de 4 (muy pequeño). Se está utilizando la columna ùser_id` del índice
de la tabla ùp` y de la base de datos `futbol` analizando una única fila para cada fila de la tabla
contigua.
TAREA 22: Desarrolle una práctica en la que utilice una base de datos con registros sin el uso de
índices de forma inicial, genere varios análisis con una consulta multitabla que cumpla:
 Uso de subconsulta
 Uso de producto cartesiano
 Uso de composición
Agregue índices a las tablas relacionadas y repita los análisis.
PARTICIONES DE TABLAS
Cuando alguna de las tablas de su base de datos llega a crecer tanto, el rendimiento empieza a ser
un problema, esta situación le indicará que es hora de empezar a leer algo sobre su optimización u
además sobre índices; el comando EXPLAIN sería una buena alternativa para realizar un análisis.
Una característica algo menos conocida, aunque se introdujo en la versión 5.1 de MySQL, son las
particiones.
Tomando como ejemplo una base de datos, que registra información hospitalaria, una de las
mayores tablas con la que hay que lidiar, es la que almacena todos y cada uno de los contratos de
todas las personas que laboran y/o han laborado que alguna vez en el hospital, considere que se
tienen datos desde que se fundó en los años 50. Esto supone que existen un par de cientos de miles
de registros, lo cual no debería dar muchos dolores de cabeza con una base de datos bien
optimizada, que aplique consultas razonables, y un hardware decente. Sin embargo, hay personas
que tienen que tratar con cantidades de datos realmente enormes, que multiplican estos números
por 10 veces 10.
Una solución que nos puede venir a la cabeza, sobre todo si la mayor parte de la información se
almacena a modo de histórico y no se accede a ella frecuentemente, es dividir la tabla en varias
porciones. Por ejemplo Podríamos mantener una tabla para el año en curso y otra para el resto de
años; o una para cada uno de los años; o una por lustro; o por década… esto dependerá de cómo
usted desee organizar los datos.
El particionado es un concepto parecido a lo expuesto en los párrafos anteriores, aunque

automatizado, que puede ahorrarnos muchos dolores de cabeza. Consiste en dividir los datos en
particiones más pequeñas (hasta 1024), ya que sólo hay que acceder a una partición a la hora de
buscar registros.
Se puede particionar una tabla de 5 maneras diferentes:

 Por rango: para lograr particiones por rangos de utiliza límites de valores. Por ejemplo,
podríamos segmentar los datos en 12 particiones: una para los contratos de 1950 a 1960,
otra para los años 60, los 70, 80, 90, la década del 2000 y la década actual:
mysql>ALTER TABLE contratos
PARTITION BY RANGE (YEAR(fechaInicio)) (
PARTITION partDecada50 VALUES LESS THAN (1960),
PARTITION partDecada10 VALUES LESS THAN MAXVALUE);
 Por listas: para construir nuestras particiones especificamos listas de valores concretos.
ALTER TABLE contratos
PARTITION BY LIST(YEAR(fechaInicio)) (
PARTITION partDecada50 VALUES IN (1950, 1951, 1952, 1953, 1954, 1955, 1956, 1957, 1958, 1959),
PARTITION partDecada10 VALUES IN (2010, 2011, 2012, 2013, 2014, 2015, 2016, 2017, 2018, 2019)
);
 Por hash: MySQL se encarga de distribuir los registros automáticamente usando una
operación de módulo. Sólo hay que pasarle una columna o expresión que resulte en un
entero (el hash) y el número de particiones que queramos crear.
PARTITION BY HASH(YEAR(fechaInicio))
PARTITIONS 7;
 Por clave: similar a la partición por hash, pero en este caso no necesitamos pasarle un
entero; MySQL utilizará su propia función de hash para generarlo. Si no se indica ninguna
columna a partir de la que desea generar el hash, se utiliza la clave primaria por defecto.
PARTITION BY KEY()
PARTITIONS 7;
 Compuesta: podemos combinar los distintos métodos de particionado y crear particiones de

particiones
Por último, un pequeño ejemplo de cómo afectaría el particionado a una consulta sencilla
como obtener el número total de registros que cumplen una condición. Estas son las
estadísticas de la consulta sin particionado (ni índices)
EXPLAIN SELECT COUNT(*)
FROM contratos
WHERE fechaInicio BETWEEN '1950-01-01' AND '1955-12-31'
select_type table type key rows Extra

SIMPLE contratos ALL 239796 Using where

Y este el resultado de añadir las particiones (nótese la palabra clave PARTITIONS para que
nos muestre también la información relativa a las particiones)
EXPLAIN PARTITIONS SELECT COUNT(*)
FROM contratos
WHERE fechaInicio BETWEEN '1950-01-01' AND '1955-12-31'
select_type table partitions type key rows Extra

SIMPLE contratos partDecada50 ALL 8640 Using where
Como puede ver, el número de registros que MySQL tiene que comprobar disminuyó en 2 órdenes
de magnitud.
Particionar tablas en MySQL nos permite rotar la información de nuestras tablas en diferentes
particiones, consiguiendo así realizar consultas más rápidas y recuperar espacio en disco al borrar
los registros. El uso más común de particionado es según fecha (date).
Para ver si nuestra base de datos soporta particionado simplemente ejecutamos:

SHOW VARIABLES LIKE '%partition%';
A continuación veremos un ejemplo de cómo particionar una tabla por mes y posteriormente borrar
o modificar su información.
CREAR PARTICIONES
1.- Creamos la tabla reportes:
CREATE TABLE reportes (
id int(10) NOT NULL AUTO_INCREMENT,
fecha datetime NOT NULL,
reporte TEXT,
PRIMARY KEY (id, fecha)
) ENGINE=InnoDB DEFAULT CHARSET=utf8
Como se puede ver hemos añadido como índice de tabla el campo fecha, esto es necesario si luego
queremos particionar por fecha.
2.- Ahora que tenemos la tabla creada vamos a particionar por mes:
ALTER TABLE reportes PARTITION BY RANGE(TO_DAYS(fecha))(
PARTITION p201111 VALUES LESS THAN (TO_DAYS("2011-12-01")),
PARTITION pDefault VALUES LESS THAN MAXVALUE
);
La última partición (pDefault) tendrá todos los registros que no entren en las particiones anteriores.
De esta manera nos aseguramos que la información nunca dejará de insertarse en la tabla.

BORRAR PARTICIONES
Lo bueno de trabajar con particiones es que podemos borrar rápidamente registros sin tener que
recorrer toda la tabla e inmediatamente recuperar el espacio en disco utilizado por la tabla.
Por ejemplo si queremos borrar la partición más antigua simplemente ejecutamos:

ALTER TABLE reportes DROP PARTITION p201111;
AÑADIR PARTICIONES
En el ejemplo anterior las 2 últimas particiones creadas han sido:
PARTITION pDefault VALUES LESS THAN MAXVALUE
El problema es que todos los INSERTs que se hagan después de mayo de 2012 se insertarán en
pDefault. La solución sería añadir particiones nuevas para cubrir los próximos meses:
ALTER TABLE reportes REORGANIZE PARTITION pDefault INTO (
PARTITION pDefault VALUES LESS THAN MAXVALUE);
En el caso que no tuviéramos una partición del tipo pDefault simplemente ejecutamos:
ALTER TABLE reports ADD PARTITION (PARTITION p201206 VALUES LESS THAN (TO_DAYS("2012-07-01")));
CONSULTAR PARTICIONES
Para consultar información de particiones creadas en una tabla así como también los registros que
contiene cada una ejecutamos:
SELECT PARTITION_NAME, TABLE_ROWS FROM information_schema.PARTITIONS
WHERE TABLE_NAME='reportes';


TAREA 23: Investigue que formas adicionales de partición ofrecen otros gestores de bases de
datos, desarrolle un análisis y justifique su criterio.

ANEXO I (RESUMEN DE COMANDOS MYSQL)
Operaciones Básicas
OPERACIÓN COMANDO
Entrar a la consola de MySQL Mysql
Entrar a la consola de MySQL como el mysql -u usuario -p
usuario usuario
Salir de la consola de MySQL \q
Ayuda de la consola (hay que estar en \help o \h
ella)
Operaciones con Bases de datos

OPERACIÓN COMANDO
Crear base de datos create database basededatos ;
Eliminar base de datos drop database basededatos ;
Mostrar las bases de datos disponibles show databases ;
Trabajar sobre con una base de datos use basededatos ;
Operaciones con Tablas

OPERACIÓN COMANDO
Mostrar tablas de la BD show tables from basededatos ;
Muestra los campos de la tabla show columns from tabla ; o describe tabla ;
Crear tabla create table nombretabla (columna1 tipodato, columna2
tipodato...) ;
Crear tabla temporal create temporary table nombretabla (columna1 tipodato);
Crear tabla verificando que no existe create table inf not exists nombretabla (columna1 tipodato,
columna2 tipodato...) ;
Eliminar tabla drop table nombretabla ;
Editar tabla alter table nombretabla operacion ;
Cambiar nombre a tabla alter table nombretablaviejo rename nombretablanuevo;
Bloquea tabla lock nombretabla1, nombretabla2... ;
Desbloquea tabla unlock nombretabla1 READ|WRITE, nombretabla2 READ|WRITE... ;
- -
Operaciones con Columnas

OPERACIÓN COMANDO
Añadir columna alter table nombretabla ADD nombrecolumna tipodato;
Cambia el tipo de dato de la alter table nombretabla change nombrecolumna nombrecolumna
columna nuevotipodato;
Cambiar el nombre de la columna alter table nombretabla change nombrecolumnaviejo
nombrecolumnanuevo tipodato;
Eliminar columna alter table nombretabla drop nombrecolumna;
Añadir índice a columna create index nombreíndice on nombretabla (nombrecolumna1,...);
ó alter table nombretabla add index (nombrecolumna);
Añadir campo clave (key) create primary key on nombretabla (nombrecolumna1,...); ó
alter table nombretabla add primary key (nombrecolumna);
Eliminar campo clave (key) alter table nombretabla drop primary key;

Operaciones con Datos

OPERACIÓN COMANDO
Insertar nuevo dato en tabla insert into nombretabla values
(valorcampo1,'valorcampo2',valorcampo3...);
Importar archivo de datos a tabla load data infile 'archivo.txt' into table nombretabla;
Seleccionar datos de una tabla select nombrecampo1, nombrecampo2... from nombretabla where
condición
Borrar todos los datos de una tabla delete from nombretabla;
(conserva la tabla con sus campos)
Actualizar un dato del campo1 update nombretabla SET nombrecampo1='nuevovalorcampo'
WHERE nombrecampo2='valorcampo2';
Contar registros que cumplen un select count(campos) from nombretabla;
criterio
Operaciones con Índices

OPERACIÓN COMANDO
Crear índice create index nombreindice on
nombretabla(listanombrescolumnas);
Elimina índice drop index indexname on tablename; o alter table nombretabla
drop index nombreindice;
Mostrar claves show keys from nombretabla ; o show index from nombretabla;

ANEXO II (OTROS EJEMPLOS DE USO DE 'ALTER TABLE' EN MYSQL)
SOBRE LA TABLA
ALTER TABLE ejemplo ENGINE = InnoDB

Cambiar el tipo de motor (engine) de la tabla 'ejemplo' ALTER TABLE personas RENAME usuarios
Cambia el nomnbre de la tabla 'personas' a 'usuarios'
ALTER TABLE ejemplo AUTO_INCREMENT=1000

En la tabla 'ejemplo' cualquiera que sea la columna que tenga 'AUTO_INCREMENT' en sus
propiedades (solo puede haber una), los nuevos registros comenzarán a partir de '1000' o cualquier
número indicado, no es posible utilizar un valor ya existente.
ALTER TABLE ejemplo CONVERT TO CHARACTER SET latin1

La tabla 'ejemplo' ahora almacenará sus valores en base al juego de caracteres 'latin1' (iso-8859-1).
OPERACIONES CON DROP
ALTER TABLE ejemplo DROP COLUMN nombre

Elimina la columna 'nombre' de la tabla 'ejemplo'.
ALTER TABLE ejemplo DROP COLUMN nombre, DROP COLUMN paterno

Elimina más de una columna.
ALTER TABLE ejemplo DROP COLUMN nombre, DROP COLUMN paterno

Elimina más de una columna.
ALTER TABLE ejemplo DROP INDEX usuario

Elimina el índice 'usuario'.
ALTER TABLE ejemplo DROP PRIMARY KEY

Elimina la llave primaria de la tabla 'ejemplo'
ALTER TABLE ejemplo DROP FOREIGN KEY id_usuario

Elimina de la tabala 'ejemplo' la llave foranea 'id_usuario'.
OPERACIONES CON CHANGE Y MODIFY
ALTER TABLE ejemplo CHANGE monto cantidad FLOAT(8,2)

Cambia el nombre de la columna 'monto' al nuevo nombre 'cantidad' con la definición del tipo de
datos.
ALTER TABLE ejemplo CHANGE cantidad cantidad FLOAT(10,2)

Cambia solo el tipo de datos de la columna, conservando el mismo nombre.
ALTER TABLE ejemplo MODIFY cantidad FLOAT(10,2)
Cambia solo el tipo de datos de la columna, conservando el mismo nombre. (Igual que el anterior)

ALTER TABLE ejemplo MODIFY cantidad FLOAT(6,2) NOT NULL

Cambia el tipo de datos de la columna 'cantidad' y especifica que no admite nulos.
ALTER TABLE ejemplo MODIFY paterno VARCHAR(30)

Modifica el tamaño de la columna 'paterno'.
ALTER TABLE ejemplo MODIFY correo CONVERT TO CHARACTER SET utf8

Es posible convertir solo una columna, en este caso 'correo' a un juego de caracteres distinto al de
todo el resto de la tabla.
OPERACIONES CON ADD
ALTER TABLE ejemplo ADD fecha DATE

Añade una columna llamada 'fecha' del tipo 'DATE' al final de todas las demás existentes.
ALTER TABLE ejemplo ADD INDEX(categoria)

Añade un índice a la columna 'categoria'.
ALTER TABLE ejemplo ADD INDEX(categoria), ADD PRIMARY KEY(clave)

Añade un índice a la columna 'categoria' y además crea la llave primaria en la columna 'clave'.
ALTER TABLE ejemplo ADD UNIQUE(email)

Añade a la columna 'email' un índice del tipo único, no puede haber dos iguales.
ALTER TABLE ejemplo ADD consecutivo BIGINT AUTO_INCREMENT, ADD INDEX(consecutivo)

Añade la columna 'consecutivo' con la característica de auto incremento y además genera un índice
sobre la misma.
ALTER TABLE ejemplo ADD materno VARCHAR(20) AFTER paterno

Añade la columna 'materno' después de la columna 'paterno'.
ALTER TABLE ejemplo ADD id INT FIRST

Añade la columna 'id' en primer lugar con respecto a las existentes.
ALTER TABLE usuarios ADD FOREIGN KEY(id) REFERENCES entradas(id_user)

Añade un 'Foreign key' en la columna 'id' de la tabla 'usuarios' que apunta a la columna 'id_user' de
la tabla 'entradas'.

ANEXO III (FUNCIONES DEL LENGUAJE DE MySQL)
Si consideramos que MySQL es rico en lo que respecta a operadores, en lo que se refiere a

funciones, podemos considerarlo millonario. MySQL dispone de multitud de funciones.
Pero no las explicaremos aquí, ya que este curso incluye una referencia completa. Tan sólo las
agruparemos por tipos, e incluiremos los enlaces correspondientes a la documentación de cada
una.
FUNCIONES DE CONTROL DE FLUJO

Las funciones de esta categoría son:
IF Elección en función de una expresión booleana
IFNULL Elección en función de si el valor de una expresión es NULL
NULLIF Devuelve NULL en función del valor de una expresión
FUNCIONES MATEMÁTICAS
Las funciones de la categoría de matemáticas son:
ABS Devuelve el valor absoluto
ACOS Devuelve el arcocoseno
ASIN Devuelve el arcoseno
ATAN y ATAN2 Devuelven el arcotangente
CEILING y CEIL Redondeo hacia arriba
COS Coseno de un ángulo
COT Cotangente de un ángulo
CRC32 Cálculo de comprobación de redundancia cíclica
DEGREES Conversión de grados a radianes
EXP Cálculo de potencias de e
FLOOR Redondeo hacia abajo
LN Logaritmo natural
LOG Logaritmo en base arbitraria
LOG10 Logaritmo en base 10
LOG2 Logaritmo en base dos
MOD o % Resto de una división entera
PI Valor del número π
POW o POWER Valor de potencias
RADIANS Conversión de radianes a grados
RAND Valores aleatorios
ROUND Cálculo de redondeos
SIGN Devuelve el signo
SIN Cálculo del seno de un ángulo
SQRT Cálculo de la raíz cuadrada
TAN Cálculo de la tangente de un ángulo
TRUNCATE Elimina decimales
FUNCIONES DE CADENAS
Las funciones para tratamiento de cadenas de caracteres son:
ASCII Valor de código ASCII de un carácter
BIN Converión a binario
BIT_LENGTH Cálculo de longitud de cadena en bits
CHAR Convierte de ASCII a carácter
CHAR_LENGTH o Cálculo de longitud de cadena en caracteres

CHARACTER_LENGTH
COMPRESS Comprime una cadena de caracteres
CONCAT Concatena dos cadenas de caracteres
CONCAT_WS Concatena cadenas con separadores
CONV Convierte números entre distintas bases
ELT Elección entre varias cadenas
EXPORT_SET Expresiones binarias como conjuntos
FIELD Busca el índice en listas de cadenas
FIND_IN_SET Búsqueda en listas de cadenas
HEX Conversión de números a hexadecimal
INSERT Inserta una cadena en otra
INSTR Busca una cadena en otra
LEFT Extraer parte izquierda de una cadena
LENGTH u OCTET_LENGTH Calcula la longitud de una cadena en bytes
LOAD_FILE Lee un fichero en una cadena
LOCATE o POSITION Encontrar la posición de una cadena dentro de otra
LOWER o LCASE Convierte una cadena a minúsculas
LPAD Añade caracteres a la izquierda de una cadena
LTRIM Elimina espacios a la izquierda de una cadena
MAKE_SET Crea un conjunto a partir de una expresión binaria
OCT Convierte un número a octal
ORD Obtiene el código ASCII, incluso con caracteres multibyte
QUOTE Entrecomilla una cadena
REPEAT Construye una cadena como una repetición de otra
REPLACE Busca una secuencia en una cadena y la sustituye por otra
REVERSE Invierte el orden de los caracteres de una cadena
RIGHT Devuelve la parte derecha de una cadena
RPAD Inserta caracteres al final de una cadena
RTRIM Elimina caracteres blancos a la derecha de una cadena
SOUNDEX Devuelve la cadena "soundex" para una cadena concreta
SOUNDS LIKE Compara cadenas según su pronunciación
SPACE Devuelve cadenas consistentes en espacios
SUBSTRING o MID Extraer subcadenas de una cadena
SUBSTRING_INDEX Extraer subcadenas en función de delimitadores
TRIM Elimina sufijos y/o prefijos de una cadena.
UCASE o UPPER Convierte una cadena a mayúsculas
UNCOMPRESS Descomprime una cadena comprimida mediante COMPRESS
UNCOMPRESSED_LENGTH Calcula la longitud original de una cadena comprimida
UNHEX Convierte una cadena que representa un número hexadecimal a
cadena de caracteres
FUNCIONES DE COMPARACIÓN DE CADENAS

Además de los operadores que vimos para la comparación de cadenas, existe una función:
STRCMP Compara cadenas
FUNCIONES DE FECHA
Funciones para trabajar con fechas:
ADDDATE Suma un intervalo de tiempo a una fecha
ADDTIME Suma tiempos
CONVERT_TZ Convierte tiempos entre distintas zonas horarias
CURDATE o CURRENTDATE Obtener la fecha actual
CURTIME o CURRENT_TIME Obtener la hora actual

DATE Extraer la parte correspondiente a la fecha

DATEDIFF Calcula la diferencia en días entre dos fechas
DATE_ADD Aritmética de fechas, suma un intervalo de tiempo
DATE_SUB Aritmética de fechas, resta un intervalo de tiempo
DATE_FORMAT Formatea el valor de una fecha
DAY o DAYOFMONTH Obtiene el día del mes a partir de una fecha
DAYNAME Devuelve el nombre del día de la semana
DAYOFWEEK Devuelve el índice del día de la semana
DAYOFYEAR Devuelve el día del año para una fecha
EXTRACT Extrae parte de una fecha
FROM_DAYS Obtener una fecha a partir de un número de días
FROM_UNIXTIME Representación de fechas UNIX en formato de cadena
GET_FORMAT Devuelve una cadena de formato
HOUR Extrae la hora de un valor time
LAST_DAY Devuelve la fecha para el último día del mes de una
fecha
MAKEDATE Calcula una fecha a partir de un año y un día del año
MAKETIME Calcula un valor de tiempo a partir de una hora, minuto
y segundo
MICROSECOND Extrae los microsegundos de una expresión de
fecha/hora o de hora
MINUTE Extrae el valor de minutos de una expresión time
MONTH Devuelve el mes de una fecha
MONTHNAME Devuelve el nombre de un mes para una fecha
NOW o CURRENT_TIMESTAMP o LOCALTIME o Devuelve la fecha y hora actual
LOCALTIMESTAMP o SYSDATE
PERIOD_ADD Añade meses a un periodo (año/mes)
PERIOD_DIFF Calcula la diferencia de meses entre dos periodos
(año/mes)
QUARTER Devuelve el cuarto del año para una fecha
SECOND Extrae el valor de segundos de una expresión time
SEC_TO_TIME Convierte una cantidad de segundos a horas, minutos y
segundos
STR_TO_DATE Obtiene un valor DATETIME a partir de una cadena con
una fecha y una cadena de formato
SUBDATE Resta un intervalo de tiempo de una fecha
SUBTIME Resta dos expresiones time
TIME Extrae la parte de la hora de una expresión fecha/hora
TIMEDIFF Devuelve en tiempo entre dos expresiones de tiempo
TIMESTAMP Convierte una expresión de fecha en fecha/hora o
suma un tiempo a una fecha
TIMESTAMPADD Suma un intervalo de tiempo a una expresión de
fecha/hora
TIMESTAMPDIFF Devuelve la diferencia entre dos expresiones de
fecha/hora
TIME_FORMAT Formatea un tiempo
TIME_TO_SEC Convierte un tiempo a segundos
TO_DAYS Calcula el número de días desde el año cero
UNIX_TIMESTAMP Devuelve un timestamp o una fecha en formato UNIX,
segundos desde 1070
UTC_DATE Devuelve la fecha UTC actual
UTC_TIME Devuelve la hora UTC actual
UTC_TIMESTAMP Devuelve la fecha y hora UTC actual

WEEK Calcula el número de semana para una fecha

WEEKDAY Devuelve el número de día de la semana para una
fecha
WEEKOFYEAR Devuelve el número de la semana del año para una
fecha
YEAR Extrae el año de una fecha
YEARWEEK Devuelve el año y semana de una fecha
DE BÚSQUEDA DE TEXTO
Función de búsqueda de texto:
MATCH
FUNCIONES DE CASTING (CONVERSIÓN DE TIPOS)

CAST o CONVERT Conversión de tipos explícita
MISCELANEA
Funciones generales:
DEFAULT Devuelve el valor por defecto para una columna
FORMAT Formatea el número según la plantilla '#,###,###.##
GET_LOCK Intenta obtener un bloqueo con el nombre dado
INET_ATON Obtiene el entero equivalente a la dirección de red dada en formato de cuarteto con
puntos
INET_NTOA Obtiene la dirección en formato de cuarteto con puntos dado un entero
IS_FREE_LOCK Verifica si un nombre de bloqueo está libre
IS_USED_LOCK Verifica si un nombre de bloqueo está en uso
MASTER_POS_WAIT Espera hasta que el esclavo alcanza la posición especificada en el diario maestro
RELEASE_LOCK Libera un bloqueo
UUID Devuelve un identificador único universal
DE GRUPOS
Funciones de grupos:
AVG Devuelve el valor medio
BIT_AND Devuelve la operación de bits AND para todos los bits de una expresión
BIT_OR Devuelve la operación de bits OR para todos los bits de una expresión
BIT_XOR Devuelve la operación de bits XOR para todos los bits de una expresión
COUNT Devuelve el número de valores distintos de NULL en las filas recuperadas por una
sentencia SELECT
COUNT DISTINCT Devuelve el número de valores diferentes, distintos de NULL
GROUP_CONCAT Devuelve una cadena con la concatenación de los valores de un grupo
MIN Devuelve el valor mínimo de una expresión
MAX Devuelve el valor máximo de una expresión
STD o STDDEV Devuelve la desviación estándar de una expresión
SUM Devuelve la suma de una expresión
VARIANCE Devuelve la varianza estándar de una expresión

ANEXO IV (ERRORES Y SUS CÓDIGOS)
SQLSTATE vs códigos de error MySQL
En teoría es mejor utilizar codigos SQLSTATE porque son independientes de la plataforma y hacen a
nuestro código más portable. Sin embargo, hay algunas razones para utilizar el código de error de
MySQL, específicamente en la escritura de Stored Procedures.
 El lenguaje para la escritura de procedimientos almacenados en Oracle y SQL Server es

totalmente incompatible con el de MySQL. El de DB2, es algo más compatible (ambos
basados en SQL:2003 standard).
 No todos los códigos de error MySQL tienen su equivalente en código SQLSTATE. Cada error
de Mysql está relacionado con un código de error SQLState, pero no siempre esta relación es
uno a uno. HY000 es un código de error SQLSTATE para propósitos generales que devuelve
MySQL cuando su código de error no tiene asociado un código SQLSTATE.
Errores comumes MySQL y códigos SQLSTATE

CÓDIGO DE CÓDIGO MENSAJE DE ERROR
ERROR SQLSTATE
MYSQL
1011 HY000 Error on delete of ‘%s’ (errno: %d)
1021 HY000 Disk full (%s); waiting for someone to free some space . . .
1022 23000 Can’t write; duplicate key in table ‘%s’
1027 HY000 ‘%s’ is locked against change
1036 HY000 Table ‘%s’ is read only
1048 23000 Column ‘%s’ cannot be null
1062 23000 Duplicate entry ‘%s’ for key %d
1099 HY000 Table ‘%s’ was locked with a READ lock and can’t be
updated
1100 HY000 Table ‘%s’ was not locked with LOCK TABLES
1104 42000 The SELECT would examine more than MAX_JOIN_SIZE
rows; check your WHERE and use SET SQL_BIG_SELECTS=1
or SET SQL_MAX_JOIN_WHERE and use SET
SQL_BIG_SELECTS=1 or SET SQL_MAX_JOIN_SIZE=# if the
SELECT is okay
1106 42000 Incorrect parameters to procedure ‘%s’
1114 HY000 The table ‘%s’ is full
1150 HY000 Delayed insert thread couldn’t get requested lock for table
%s
1165 HY000 INSERT DELAYEDcan’t be used with table ‘%s’ because it is
locked withLOCK TABLES
1242 21000 Subquery returns more than 1 row
1263 22004 Column set to default value; NULL supplied to NOT NULL
column ‘%s’ at row %ld
1264 22003 Out of range value adjusted for column ‘%s’ at row %ld
1265 1000 Data truncated for column ‘%s’ at row %ld
1312 0A000 SELECTin a stored program must haveINTO
1317 70100 Query execution was interrupted
1319 42000 Undefined CONDITION: %s
1325 24000 Cursor is already open

1329 2000 No data to FETCH

1336 1337 42000 42000 USEis not allowed in a stored program Variable or
condition declaration after cursor or handler declaration
1338 42000 Cursor declaration after handler declaration
1339 20000 Case not found for CASE statement
1348 1357 HY000 HY000 Column ‘%s’ is not updatable Can’t drop a %s from within
another stored routine
1358 1362 HY000 HY000 GOTOis not allowed in a stored program handler
1363 HY000 Updating of %s row is not allowed in %s trigger There is no
%s row in %s trigger

ANEXO V (Posibilidades de utilizar los permisos de usuarios en MySQL)
PERMISO SIGNIFICADO
ALL [PRIVILEGES] Da todos los permisos simples excepto GRANT OPTION
ALTER Permite el uso de ALTER TABLE
ALTER ROUTINE Modifica o borra rutinas almacenadas
CREATE Permite el uso de CREATE TABLE
CREATE ROUTINE Crea rutinas almacenadas
CREATE Permite el uso de CREATE TEMPORARY TABLE
TEMPORARY
TABLES
CREATE USER Permite el uso de CREATE USER, DROP USER, RENAME USER, y REVOKE ALL
PRIVILEGES.
CREATE VIEW Permite el uso de CREATE VIEW
DELETE Permite el uso de DELETE
DROP Permite el uso de DROP TABLE
EXECUTE Permite al usuario ejecutar rutinas almacenadas
FILE Permite el uso de SELECT ... INTO OUTFILE y LOAD DATA INFILE
INDEX Permite el uso de CREATE INDEX y DROP INDEX
INSERT Permite el uso de INSERT
LOCK TABLES Permite el uso de LOCK TABLES en tablas para las que tenga el permiso SELECT
PROCESS Permite el uso de SHOW FULL PROCESSLIST
REFERENCES No implementado
RELOAD Permite el uso de FLUSH
REPLICATION Permite al usuario preguntar dónde están los servidores maestro o esclavo
CLIENT
REPLICATION Necesario para los esclavos de replicación (para leer eventos del log binario desde el
SLAVE maestro)
SELECT Permite el uso de SELECT
SHOW DATABASES SHOW DATABASES muestra todas las bases de datos
SHOW VIEW Permite el uso de SHOW CREATE VIEW
SHUTDOWN Permite el uso de mysqladmin shutdown
SUPER Permite el uso de comandos CHANGE MASTER, KILL, PURGE MASTER LOGS, and SET
GLOBAL , el comando mysqladmin debug le permite conectar (una vez) incluso si se
llega a max_connections
UPDATE Permite el uso de UPDATE
USAGE Sinónimo de “no privileges”
GRANT OPTION Permite dar permisos

RESPUESTAS
EJERCICIOS PROPUESTOS EN PROCEDIMIENTOS
1. Un procedimiento almacenado para obtener el IdEspecialidad, para esto se utiliza como
argumento el identificador a devolver y el nombre de la especialidad.
2. Un procedimiento almacenado para obtener el Idcurso, para esto se utiliza como argumento
el identificador a devolver y el nombre del curso.
3. Un procedimiento almacenado para obtener el Idparalelo, para esto se utiliza como
argumento el identificador a devolver y la letra del paralelo
4. Crear un procedimiento almacenado que permita registra la matriculación de un estudiante.
CREATE PROCEDURE BuscaIdEsp(OUT IdBuscar integer, IN espec varchar(50))

SELECT IdEspecialidad INTO IdBuscar FROM Especialidades WHERE nombreEspecialidad= espec;
CREATE PROCEDURE BuscaIdCur(OUT IdBuscar integer, IN cur varchar(30))

SELECT IdCurso INTO IdBuscar FROM Cursos WHERE curso= cur;
CREATE PROCEDURE BuscaIdPara(OUT IdBuscar integer, IN Para varchar(30))

SELECT IdParalelo INTO IdBuscar FROM Paralelos WHERE Paralelo= Para;
Delimiter //
CREATE PROCEDURE AgregaMatricula1 (ApPat varchar(50),ApMat varchar(50),Nomb varchar(50),
ApPatR varchar(50),ApMatR varchar(50),NombR varchar(50), Cur varchar(20),Par varchar(1),Esp
varchar(30), Folder varchar(50))
BEGIN
DECLARE IdRep INTEGER;
DECLARE IdEsp INTEGER;
DECLARE IdCur INTEGER;
DECLARE IdPar INTEGER;
DECLARE IdPL INTEGER;
SELECT IdPersona INTO IdEst FROM Personas WHERE concat(ApellidoPaterno,' ',ApellidoMaterno,'
',Nombres)= concat(ApPat,' ',ApMat,' ',Nomb);
SELECT IdPersona INTO IdRep FROM Personas WHERE concat(ApellidoPaterno,' ',ApellidoMaterno,'
',Nombres)= concat(ApPatR,' ',ApMatR,' ',NombR);
SELECT IdEspecialidad INTO Idesp FROM Especialidades WHERE nombreEspecialidad= Esp;
SELECT IdCurso INTO IdCur FROM Cursos WHERE curso= cur;
SELECT IdParalelo INTO IdPar FROM Paralelos WHERE Paralelo= Par;
SELECT MAX(IdPeriodoLectivo) INTO IdPL FROM Periodoslectivos;
INSERT INTO Matriculas(IdPersonaEstudiante, IdPeriodolectivo, IdEspecialidad, IdCurso,
IdParalelo,IdPersonaRepresentante, folder) VALUES (IdEst, IdPL,IdEsp, IdCur, IdPar, IdRep,Folder);
END//
delimiter ;

Delimiter //
CREATE PROCEDURE AgregaMatricula2 (ApPat varchar(50),ApMat varchar(50),Nomb varchar(50),
ApPatR varchar(50),ApMatR varchar(50),NombR varchar(50), Cur varchar(20),Par varchar(1),Esp
varchar(30), Folder varchar(50))
BEGIN
DECLARE IdRep INTEGER;
DECLARE IdEsp INTEGER;
DECLARE IdCur INTEGER;
DECLARE IdPar INTEGER;
DECLARE IdPL INTEGER;
CALL BuscaId(IdEst,ApPat,ApMat,Nomb);
CALL BuscaId(IdRep,ApPatR,ApMatR,NombR);
CALL BuscaIdEsp(Idesp,Esp);
CALL BuscaIdCur(IdCur,Cur);
CALL BuscaIdPara(IdPar,Par);
SELECT MAX(IdPeriodoLectivo) INTO IdPL FROM Periodoslectivos;
INSERT INTO Matriculas(IdPersonaEstudiante, IdPeriodolectivo, IdEspecialidad, IdCurso,
IdParalelo,IdPersonaRepresentante, folder)
VALUES (IdEst, IdPL,IdEsp, IdCur, IdPar, IdRep,Folder);
END//
Delimiter ;
EJERCICIOS PROPUESTOS DE FUNCIONES

1. Elabore una función que permita calcular la factorial de un número.
2. Elabore una función que devuelva el número de hijos que tiene registrados en la base de
datos, utilice como argumento el identificador del padre.
Delimiter //
CREATE FUNCTION factorial(n int) RETURNS int
BEGIN
DECLARE f int;
DECLARE counter integer;
SET f=1;
SET counter = n;
WHILE counter > 1 DO
SET f= f * counter;
SET counter = counter - 1;
END WHILE;
RETURN f;
END//
Delimiter ;
Para ejecutarlo: SELECT factorial(6);
Delimiter //
CREATE FUNCTION Hijos(id int) RETURNS int

Begin
DECLARE total int Default 0;
SELECT Count(*) INTO total FROM Estudiante WHERE IdPersonaPapa=id;
RETURN total;
END //
DELIMITER ;
Para ejecutarlo:
SELECT DISTINCT personas.ApellidoPaterno, personas.ApellidoMaterno, personas.Nombres,
Hijos(personas.IdPersona) as ‘num de hijos’
FROM personas INNER JOIN estudiante ON personas.IdPersona = estudiante.IdPersonaPapa;
EJERCICIO PROPUESTO DE CURSORES:

Modofique el procedimiento almacenado que asigna profesores de dibujo, ingles y cultura física a la
comisión social, de manera que se le pueda pasar como argumento el nombre de la materia, el
nombre de la comisión a ser asignado y el número de horas.
Delimiter //
CREATE PROCEDURE AsignaComisiones(v_materia varchar(50), v_comision varchar(50), v_numeroHoras int)
BEGIN
DECLARE Limite BOOLEAN DEFAULT FALSE;
DECLARE v_IdPeriodoActual INTEGER;
DECLARE v_IdMateria INTEGER;
DECLARE v_IdProfesor INTEGER;
DECLARE v_IdEspecialidad INTEGER;
DECLARE v_IdCurso INTEGER;
DECLARE v_IdParalelo INTEGER;
#Llenado del cursor mediante la consulta
DECLARE Lista cursor for SELECT IdPersonaProfesor, IdEspecialidad, IdCurso, iDParalelo FROM materias,
materiasprofesores WHERE materias.IdMateria = materiasprofesores.IdMateria AND
materias.NombreMateria=upper(v_materia) GROUP BY idpersonaprofesor;
DECLARE CONTINUE HANDLER FOR NOT FOUND SET Limite = TRUE;
#Para obtener el identificador del periodo lectivo actual
SELECT Max(IdPeriodoLectivo) INTO v_IdPeriodoActual FROM PeriodosLectivos;
#Para Obtener el identificador de “Comisión Social”
SELECT IdMateria INTO v_IdMateria FROM Materias WHERE NombreMateria=upper(v_comision);
OPEN Lista;
c1_loop: LOOP
FETCH Lista INTO v_IdProfesor, v_IdEspecialidad, v_IdCurso, v_IdParalelo;
IF Limite THEN LEAVE c1_loop; END IF;
#Agrega al profesor a su carga la “Comisión Social”
INSERT INTO materiasprofesores ( IdPersonaProfesor, IdMateria, IdPeriodoLectivo,
IdEspecialidad, IdCurso, iDParalelo, NumeroHoras) VALUES (v_IdProfesor, v_IdMateria ,
v_IdPeriodoActual ,v_IdEspecialidad, v_IdCurso, v_IdParalelo, v_numeroHoras);
END LOOP c1_loop;
CLOSE Lista;
END //
Delimiter ;


CALL AsignaComisiones('MATEMATICAS', 'COMISION ACADEMICA',3);

CALL AsignaComisiones('FISICA', 'COMISION ACADEMICA',3);


APLICACION DE BASE DE DATOS EN MySQL PDF

Cargado por

Información del documento

Título original

Derechos de autor

Formatos disponibles

Compartir este documento

Compartir o incrustar documentos

Opciones para compartir

¿Le pareció útil este documento?

¿Este contenido es inapropiado?

Copyright:

Formatos disponibles

APLICACION DE BASE DE DATOS EN MySQL PDF

Cargado por

Copyright:

Formatos disponibles

APLICACIÓN DE

PRÁCTICAS DE BASES DE DATOS

1 Ing. Gabriel Demera Ureta MgSc.

FUNCIONES DE COMPARACIÓN DE CADENAS ................................................................................................95

3 Ing. Gabriel Demera Ureta MgSc.

El presente documento es un compendio de muchas fuentes tomadas del Internet, incluyendo

Esta domumentación tiene el propósito de introducir al estudiante o el interesado, a la

4 Ing. Gabriel Demera Ureta MgSc.

ADMINISTRACIÓN DE MYSQL MEDIANTE CONSOLA

La primera etapa contiene material de apoyo en MySQL y la segunda etapa en PostgreSQL, el

5 Ing. Gabriel Demera Ureta MgSc.

CONECCIÓN CON EL SERVIDOR MYSQL MEDIANTE CONSOLA

La sintaxis modelo sería la siguiente:

Se podría haber indicado la contraseña directamente en la línea de comandos que accede a la

COMANDOS A UTILIZAR DENTRO DE LA CONSOLA DE MYSQL

mysql> use mibasedatos;

5 rows in set (0.02 sec)

7 Ing. Gabriel Demera Ureta MgSc.

mysql> describe administrador;

4 rows in set (0.11 sec)

Otra alternativa para mostrar la estructura de una tabla es la siguiente:

PARA SALIR DE LA CONSOLA DE COMANDOS DE MYSQL

TIPOS DE DATOS DE MYSQL

8 Ing. Gabriel Demera Ureta MgSc.

1.- TIPOS DE DATOS NUMÉRICOS:

2.- TIPOS DE DATOS PARA FECHA:

TimeStamp: Combinación de fecha y hora. El rango va desde el 1 de enero de 1970 al año

9 Ing. Gabriel Demera Ureta MgSc.

3.- TIPOS DE DATOS PARA CADENAS DE TEXTO:

10 Ing. Gabriel Demera Ureta MgSc.

Diferencia de almacenamiento entre los tipos Char y VarChar

VALOR CHAR(4) ALMACE VARCHAR(4) ALMACE

La sintaxis general para crear una tabla es:

ACTUALIZACIÓN DE LA ESTRUCTURA DE UNA TABLA

 Para modifica el tamaño de la columna email, se puede utilizar:

 En la tabla ejemplo, cualquier campo que tenga en su definición la propiedad

12 Ing. Gabriel Demera Ureta MgSc.

considerando que no es posible utilizar un valor ya existente en un registro, usted podrá

 Para eliminar varias columnas se utilizará la siguiente sintaxis:

RELACIONES E INGRESOS DE DATOS

CREAR RELACIONES Y CLAVES FORANEAS

13 Ing. Gabriel Demera Ureta MgSc.

DROP DATABASE IF EXISTS Unidad;

create table if not exists padres(

INSERT INTO personas (ApellidoPaterno, ApellidoMaterno, Nombres, Direccion, telefono, sexo,

INSERT INTO personas (ApellidoPaterno, ApellidoMaterno, Nombres, Direccion, telefono, sexo,

14 Ing. Gabriel Demera Ureta MgSc.

INSERT INTO personas (ApellidoPaterno, ApellidoMaterno, Nombres, Direccion, telefono, sexo,

PROCESOS DE EXTRACCIÓN DE DATOS EN LAS TABLAS CREADAS:

Si necesitamos mostrar la lista, solo de varones casados, quedaría así:

15 Ing. Gabriel Demera Ureta MgSc.

Sí necesitamos la lista ordenada por apellido paterno de forma ascendente o descendente se

SELECT ApellidoPaterno, ApellidoMaterno, Nombres, telefono, sexo, FechaNacimiento

16 Ing. Gabriel Demera Ureta MgSc.

SELECT ApellidoPaterno, ApellidoMaterno, Nombres, sexo, direccion

17 Ing. Gabriel Demera Ureta MgSc.

Para aplicar su utilización, ejemplificamos los siguientes ejercicios:

 Para ver el promedio de edades de todas las personas registradas se aplica.

 Si se necesita conocer el número de persona clasificados por sexo:

TAREA 5: Considerando el diseño del deber anterior, plantear 5 propuestas de clasificación de

18 Ing. Gabriel Demera Ureta MgSc.

INSERT INTO Profesores (IdPersona, cargo, Titulacion, Fechaingreso)

19 Ing. Gabriel Demera Ureta MgSc.