Teoria

Objetivo: Nos permite transmitir o almacenar informacion.
Que es: Es el lenguaje de marcas extendido.

Necesitamos un nodo raiz y dentro nodos elemento.
<raiz>
<elemento nombre="ele1">
<elemento nombre="ele2">
</raiz>

Puedes elegir tanto los nombres de las etiquetas y de sus atributos. Sensible a mayusculas y minusculas.

Ejemplo de almacenamiento de informacion:
<clase>
<alumno nombre="MIKEL">
<edad>44</edad>
<sexo>h</sexo>
</alumno>
</clase>

La cabecera del XML tiene que tener la version y el encoding.
<?xml version="1.0" encoding="utf-8" ?>

A las xml se les puede aplicar hojas de estilo para visualizarlas en el navegador de una manera mas vistosa.
<?xml-stylesheet type="text/css" href="estilos.css" ?>
Se recomienda usar XSL en vez de CSS para dar estilo al XML.

Solo podremos tener un único nodo raiz.

Los nombres de los elementos y atributos no pueden empezar por numero ni contener espacio.

ejemplo deDTD: sirve para especificar las elementos y atributos que usaremos en el XML.

<!DOCTYPE NEWSPAPER [

<!ELEMENT NEWSPAPER (ARTICLE+)>
<!ELEMENT ARTICLE (HEADLINE,BYLINE,LEAD,BODY,NOTES)>
<!ELEMENT HEADLINE (#PCDATA)>
<!ELEMENT BYLINE (#PCDATA)>
<!ELEMENT LEAD (#PCDATA)>
<!ELEMENT BODY (#PCDATA)>
<!ELEMENT NOTES (#PCDATA)>

<!ATTLIST ARTICLE AUTHOR CDATA #REQUIRED>
<!ATTLIST ARTICLE EDITOR CDATA #IMPLIED>
<!ATTLIST ARTICLE DATE CDATA #IMPLIED>
<!ATTLIST ARTICLE EDITION CDATA #IMPLIED>

<!ENTITY NEWSPAPER "Vervet Logic Times">
<!ENTITY PUBLISHER "Vervet Logic Press">
<!ENTITY COPYRIGHT "Copyright 1998 Vervet Logic Press">

]>

Una alternativa al DTD puede ser xml schema:

<?xml version="1.0"?>
<xs:schema xmlns:xs="http://www.w3.org/2001/XMLSchema">

<xs:element name="note">
<xs:complexType>
<xs:sequence>
<xs:element name="to" type="xs:string"/>
<xs:element name="from" type="xs:string"/>
<xs:element name="heading" type="xs:string"/>
<xs:element name="body" type="xs:string"/>
</xs:sequence>
</xs:complexType>
</xs:element>

</xs:schema>

Anotaciones:

En el video se recomienda usar xml notepad de microsoft. Disponible en la web de microsoft.

Tipos de copia de seguridad

Copia completa

Copia de seguridad de toda la informacion, el problema es que si el volumen de informacion es grande se tardara mucho.

Copia diferencial

Copia los archivos modificados desde la ultima copia completa, siempre respecto a la copia completa. Si con el tiempo durante las copias diferenciales, van abarcando todos los archivos, la copia acaba cogiendo la magnitud de una copia completa y dejaria de ser rentable. Para restaurar este tipo de copias se necesita la copia completa y la ultima copia diferencial desde esta.
Ejemplo:
Dia 1:
Copia completa:
A
B
C
Dia 2:
Copia diferencial
A
Dia 3:
Copia diferencial
A
C

etc ...

Copia incremental

Copia los archivos modificados desde la ultima copia de seguridad que se hizo. La ventaja, respecto a las copias diferenciales, esque el volumen de cada copia es menor. El problema, esque para restaurar una copia de seguridad de este tipo, necesitaras todos los archivos de backup realizados desde la ultima copia completa.
Ejemplo:
Dia 1:
Copia completa:
A
B
C
Dia 2:
Copia incremental
A
Dia 3:
Copia incremental
C

etc ...

Esquema de copias de seguridad tipico de una empresa

1 copia completa al mes
1 copia diferencial los viernes
1 copia de seguridad incremental cada dia

Comando TAR: Realizar copias de seguridad

Ejemplo de copias de seguridad usando tar:

#Realizar una copia de seguridad completa
tar -jcvf copiacompleta_`date +%Y-%m-%d`.tar.bz2 directorio1 directorio2 ...

#Realizar una copia de seguridad diferencial
#-N te permite empaquetar y comprimir archivos desde una fecha concreta, usando un formato especial
#esto quiere decir, que esa fecha tendra dos posibles razones de ser:
#Copia diferencial: Fecha de la ultima copia completa
#Copia incremental: Fecha de la ultima copia de seguridad
tar -jcvf copiadiferencial_`date +%Y-%m-%d`.tar.bz2 -N 24feb2011 directorio1 directorio2 ...

Rsync

Hemos realizado sincronicaciones mediante esta aplicacion de linux. Se sincronizarian en otro lugar cada con una frecuencia programada.

Copias de seguridad en caliente

Se usa este termino cuando hablamos de copiar por ejemplo bases de datos sin parar antes el servicio. Realizar la copia de unos archivos mientras estan siendo usados.

Deja-DUP

Es una aplicacion de linux para realizar copias de seguridad de manera muy sencilla.
Al entrar en la aplicacion nos da dos opciones. Restaurar y respaldar, bastante evidente.
Podemos preparar una configuracion previa en Editar -> Preferencias:
- Almacenamiento: Aquí especificaremos el destino a la backup, el lugar donde la almacenaremos.
- Archivos: Podremos seleccionar los directorios y archivos concretos que querremos que se copien en la backup.
- Programacion: Aquí podremos especificar la frecuencia con la que realizaremos copias de seguridad y con cuanta antigüedad las mantendremos.

Crear un script que realice las siguientes acciones:

1.- Crear la base de datos colegio

create database colegio

2.- Crear la tabla Alumno con los campos dni, nombre y fecha_nacimiento

CREATE TABLE Alumno(
dni varchar( 9 ) NOT NULL ,
nombre varchar( 25 ) NOT NULL ,
fecha_nacimiento date,
PRIMARY KEY ( dni )
)

3.- Crear la tabla Asignatura con los campos codigo (autonumérico) y nombre

-- Los Auto-incremente tiene que ser siempre de 11 digitos, porque hay que tener un buen margen.
create table asignatura(
cod_asignatura int(11) not null AUTO_INCREMENT,
nombre varchar(25),
primary key (cod_asignatura)
)

4.- Crear la tabla Matricula con los campos dni, cod_asignatura y convocatoria.

create table matricula
(dni varchar(9) not null,
cod_asignatura int(11) not null,
convocatoria int(2) not null default 1,
primary key (dni,cod_asignatura, convocatoria),
constraint fk_dni FOREIGN key (dni) REFERENCES alumno(dni),
constraint fk_asignatura FOREIGN key (cod_asignatura) REFERENCES asignatura(cod_asignatura)
)

5.- Comprobar que estan creadas claves primarias y ajenas.

-- describe campos de la tabla
describe alumno;
describe asignatura;
describe matricula;

6.- Insertar un alumno entero: dni=11111111A,nombre=Iker,fecha nacimiento=19/1/1990

Insert into alumno
(dni, nombre, fecha_nacimiento)
values
('11111111A','Iker','1990-1-19')

7.- Insertar varios alumnos enteros

insert into alumno
(dni, nombre, fecha_nacimiento)
values
('11111111G','Iker','1990-1-19'),
('11114111A','Mikel','1990-1-13'),
('11111511C','Manuel','1990-1-18')

-- O sino, al ser todos los campos, no tenemos porque espeficicar mas que colocando cada uno en su posicion

insert into alumno
values
('11111111G','Iker','1990-1-19'),
('11114111A','Mikel','1990-1-13'),
('11111511C','Manuel','1990-1-18')

8.- Insertar solo dni y fecha nacimiento de un alumno

insert into alumno
(dni, fecha_nacimiento)
values
('11111111H','1994-1-19')

9.- Insertar las asignaturas GBD, SO y REDES

insert into asignatura
(nombre)
values
('GBD'),
('SO'),
('REDES')

10.- Modificar la tabla Matricula para que la convocatoria por defecto sea 1

alter table matricula
modify convocatoria int(2) default 1

11.- Matricular a todos los alumnos en las 3 asignaturas.

insert into matricula
(dni, cod_asignatura)
values
('11111111A',1),
('11111111A',2),
('11111111A',3),
('11111111G',1),
('11111111G',2),
('11111111G',3),
('11114111A',1),
('11114111A',2),
('11114111A',3),
('11111511C',1),
('11111511C',2),
('11111511C',3),
('11111111H',1),
('11111111H',2),
('11111111H',3)

12.- Modificar la tabla matricula para añadir el campo nota con dos decimales

-- Para los campos de tipo decimal el primer numero que metemos en el tipo es el numero de digitos que tendra el numero contando decimales.
-- Lo que ponemos despues de la coma sera el numero de posiciones decimales que guardaremos en la variable
alter table matricula
add nota decimal(4,2)

13.- Poner nota a de 5,25 a todos los alumnos de GBD.

update matricula
set nota = 5.25
where cod_asignatura = (select cod_asignatura from asignatura where nombre = 'GBD')

14.- Poner nota de 10,75 en todas las asignaturas a la alumno iker

update matricula
set nota = 10.75
where dni = (select dni from alumno where nombre = "iker")

15.- Pasar a segunda convocatoria a todos los alumnos que tengan null en la nota

update matricula
set convocatoria = 2
where nota IS NULL

16.- Obtener las notas de Iker: Nombre de asignatura, convocatoria y nota.

SELECT asignatura.nombre, convocatoria, nota
FROM asignatura inner join matricula
on asignatura.cod_asignatura = matricula.cod_asignatura
where dni = (select dni from alumno where nombre = "Iker")

17.- Eliminar el Alumno Iker

-- En MYSQL no podemos usar borrados en cascada, de forma que para borrar un alumno matriculado en algun curso, primero deberan borrarse sus matriculas
-- Y una vez este este libre de relaciones podremos borrar al alumno.
delete from matricula where dni = (select dni from alumno where nombre = "Iker");
delete from alumno where nombre = "Iker";

ANOTACIONES:

Te Muestra el script de creacion de la tabla.

SHOW CREATE TABLE NOMBRETABLA;

Devuelve los campos de la tabla.

Describe NOMBRETABLA;

Eliminar key añadida por error

ALTER TABLE matricula DROP INDEX cod_asignatura

Añadir relaciones a una tabla

alter table matricula
add constraint fk_dni foreign key (dni) REFERENCES alumno(dni),
add constraint fk_asignatura foreign key (cod_asignatura) REFERENCES asignatura(cod_asignatura)

Crear tabla con otro motor (Respetar foreign key)

CREATE TABLE `matricula2` (
`dni` varchar(9) NOT NULL,
`cod_asignatura` int(3) NOT NULL,
`convocatoria` int(2) DEFAULT '1',
`nota` decimal(2,2) DEFAULT NULL,
PRIMARY KEY (`dni`,`cod_asignatura`)
) ENGINE=InnoDB DEFAULT CHARSET=latin1

Borrar tablas

Drop table NOMBREDETABLA
o
Drop table NOMBREDETABLA1, NOMBREDETABLA2, NOMBREDETABLA3;

Asignar motor a la base de datos

-- Sirve para darle un motor especifico de base de datos InnoDB permite foreign key
create table NOMBRE
(...)
ENGINE = NOMBREMOTOR

MYSQL Evaluacion 3

Variables

Ejemplo:
SET @v1=0 , @v2=0 , @v3=0;
SELECT @v1:= (@v2:=1) + @v3:=4 , @v1 , @v2 , @v3;

NOTA: Esto es una select, pero dentro de la select que tenemos, podemos realizar operaciones usando variables, incluso asignarlas durante su uso.

Ejemplo:
inset into cliente (.......) values (......);
@ultimo:= LAST_INSERT_ID(); / Esta funcion recupera el ultimo auto_increment que se haya ejecutado
....
insert into compra (idcliente, idproducto .....)
values (@ultimo, 'peras', 34),
(@ultimo, 'nabos', 11),
(@ultimo, 'Kiwis', 22);
...
inset into cliente (.......) values (......);
@ultimo:= LAST_INSERT_ID(); / Esta funcion recupera el ultimo auto_increment que se haya ejecutado
....
insert into compra (idcliente, idproducto .....)
values (@ultimo, 'peras', 34),
(@ultimo, 'nabos', 11),
(@ultimo, 'Kiwis', 22);

Ejemplo:
select idproducto from productos where precio in (select max(preciocoste), min(preciocoste) from productos);
...
select @precio_min:= min(PrecioCoste),
@precio_max:=max(PrecioCoste)
from productos;
...
select * from productos where preciocoste = @precio_min OR preciocoste = @precio_max;

Ejercicios:

1 - Obtener los productos mas caros y mas baratos.

2 - Crear la base de datos tienda e insertar un cliente y su compra (2 pantalones y 3 camisetas)

3 - En "Pruebas" (Base de datos), introducir un pedido con fecha de envio hoy.

insert into pedidos
(IDPedido,IDCliente,FechaPedido,RetornTransportista,Entregado)
values
(200,1, current_date(),0,0)

4 - Obtener el primer y ultimo pedido.

select @primero:= min(FechaPedido) as primero, @ultimo:= max(FechaPedido) as ultimo,
from pedidos

5 - Obtener el usuario conectado y la version del servidor.

select user(), version();

6 - Obtener la fecha actual, la fecha con hora y el dia de la semana

select @fecha:= current_date(), now(), dayname(@fecha)
-- dayname te da el nombre del dia de la semana apartir de una fecha,
-- para saber el dia de la semana en el que estamos le pasamos
-- una variable que contiene el resultado de una funcion que devuelve la fecha de hoy

7 - Obtener el resultado de realizar la operacion: SEN(PI/4) * 7 / 3

select SIN(PI()/4) * 7 / 3

8 - Dar formato con dos decimales a 1234567810,839

select format(1234567810.839,2)

9 - Investigar sobre las funciones de encriptacion.

-- Funciones de encriptacion y desencriptacion, nose porque no me va bien la desencriptacion
select @texto_encriptado:= AES_ENCRYPT('Hola esto es una prueba de clase','password123');
select AES_DECRYPT(@texto_encriptado,'password123');

-- Mas funciones de codificado
select @texto_encriptado:= ENCODE('Hola esto es una prueba de clase','password123');
select DECODE(@texto_encriptado,'password123');

Ejemplo:

-- El campo de tipo varchar no nos sirve para almacenar claves, se nos desborda. Usamos el campo de tipo blob, para ello creamos una tabla.
create table claves
(
nombre varchar(20),
texto_claro varchar(20),
texto_encriptado blob
);

-- Insertamos un registro
insert into claves
(nombre, texto_claro)
values ('asier','Hola encriptado');

-- Actualizamos el registro metiendole texto encriptado en un campo
update claves
set texto_encriptado = AES_ENCRYPT(texto_claro,'miclave');

-- Recuperamos el texto encriptado apartir de la clave que usamos anteriormente
select nombre, texto_claro, AES_DECRYPT(texto_encriptado,'miclave') from claves;

Enlace para ver esto de las funciones de encriptación:

http://dev.mysql.com/doc/refman/5.0/es/encryption-functions.html

NOTA: En estos ejercicios puede ayudarte ...
last_insert_id()
dayname()
pi()
version()
current_date()
user()
now()
sin()
format()

Triggers

Nos permite ejecutar una accion antes o despues de ... una insercion, actualizacion o borrado.
Sintaxsis:
-- Podemos cambiar el delimitador por para que no acabe la consulta con los delimitadores de sentencia, al final del disparador volver a ponerlo en ; como al principio
delimiter
-- Como se crea el trigger
Create trigger NOMBREDISPARADOR
{before | after} {insert | update | delete} -- Cuando queremos ejecutarla, antes o despues de la consulta y que tipo de consulta
on NOMBRETABLA -- Tabla a la que le asignamos este disparador
for each row -- Esto quiere decir, que el disparador afectará a cada fila afectada
begin
SENTENCIAS SQL; -- Sentencias que se aplicarán a cada fila afectada, una por una
-- Podremos referirnos al campo del registro nuevo o el campo del registro viejo por medio de NEW.CAMPO o OLD.CAMPO
end//
delimitador ;

Apuntes Triggers

- Tenemos una tabla con dos campos (Texto1 y Texto2). Despues de insertar almacene "Trigger activado" en una variable (Inicializada a Hola) y que actualice Texto2 "Texto introducido por el trigger".

create trigger tr_cambiocampo
before insert on prueba_trigger
for each row
begin
set new.texto2 = 'texto introducido por trigger';
end

Delimiter

Como visualizar el trigger

SELECT *
FROM information_schema.triggers

O sino tambien

SHOW triggers LIKE 'prueba_trigger'

Probar el trigger

insert into prueba_trigger (texto1,texto2) values ('Es una prueba','caca')

Ejercicios Triggers

1 - Crear un trigger en clientes que cuando se modifique el nombre guarde el nombre viejo y el nuevo en dos variables.

create trigger tr_guardacliente
before update on clientes
for each row
begin
set @nuevo:= new.Nombre, @viejo:= old.Nombre;
end//

Prueba:

update clientes
set Nombre = "NombreDiferente"
where IDCliente = 1;
select @nuevo, @viejo;

2 - Crear un trigger que lleve un registro de quien a modificado la tabla mitabla, que valores ha modificado y a que hora.

-- Podemos usar tanto after como before, pero usamos after. Nos itneresa mas after en este caso, para que, en caso de que la consulta
-- Sea erronea, el trigger no se llegue a ejecutar.

create trigger tr_registro
after update on claves
for each row
begin
insert into registro
(id_viejo, nombre_viejo, nombre_nuevo, usuario, fecha)
values
(old.id, old.nombre, new.nombre, user(), current_date());
end//

-- Digamos que en usuario activo metemos una variable del sistema que alvergue el nombre de usuario que realiza la consulta

3 - Crear un trigger que en la tabla usuarios, encripte la contraseña antes de la insercion.

-- Creamos una tabla para probarlo
CREATE TABLE `usuarios` (
`id` int(11) NOT NULL AUTO_INCREMENT,
`usuario` varchar(20) DEFAULT NULL,
`passwd` varchar(30) DEFAULT NULL,
`enc_passwd` blob NOT NULL,
PRIMARY KEY (`id`)
) ENGINE=InnoDB DEFAULT CHARSET=latin1

-- Le creamos el trigger
create trigger tr_encpass
before insert on usuarios
for each row
begin
set new.enc_passwd = AES_ENCRYPT(new.passwd,'miclave');
end//

-- Probamos el trigger mediante una insercion
insert into usuarios
(usuario,passwd)
values
('manuel','micontra');

-- Comprobamos que la contraseña se ha almacenado correctamente
SELECT AES_DECRYPT(enc_passwd,'miclave') FROM `usuarios`;

4 - Crear un trigger que vaya acumulando en una variable (@cantidadtotal) la suma de las cantidades que se van insertando en lineadepedidos.

set @cantidadtotal:=0;
create trigger tr_acumular
after insert on lineaspedido
for each row
begin
set @cantidadtotal = @cantidadtotal + new.cantidadtotal;
end//

5 - Crear un trigger que controle la cantidad en lineadepedidos:Si es <0, que lo sustituya por 0, y si es > 100 que lo sustitya por 100

create trigger tr_cntrl_lineapedido
before insert on lineaspedido
for each row
begin
IF new.CantidadPedida < 0 then
set new.CantidadPedida = 0;
elseif new.CantidadPedida > 100 then
set new.CantidadPedida = 100;
end if;
end//

NOTA: Tener cuidado con que un trigger haga saltar a otro, puede ser un caos.

...

Condicionales

IF condicion THEN
...
ELSEIF condicion THEN
...
ELSE
...
END IF

Estructura condicional CASE

CASE variable
when valor1 then
acciones;
when valor2 then
acciones;
when valor3 then
acciones;
when valor4 then
acciones;
else
acciones;
END CASE;

Comparadores

Igualdad: =
mayor menor: > <
Diferente: <> !=

Procedimientos almacenamos

Pueden ser de entrada, salida o entrada-salida. Son como las funciones de programacion.
Sintaxis:
#Sintaxis del procedimiento
create procedure NOMBREPROC ( [IN | OUT | INOUT] PARAMETRO TIPO )
begin
declare nombre variable tipo; #Aqui se declararan las variables. Son internas para el procedimiento.
...
end//

#Sintaxis de llamada al procedimiento
call NOMBREPROC (valor1, valor2 .....);

Ejemplo: Procedimiento que cuenta cuantos registros hay en mi tabla

create procedure pr_cuentamitabla (OUT numero INT)
begin
select count(*) INTO numero FROM mitabla; #INTO nos permitira guardar el resultado de la select dentro del parametro (podras usarlo con cualquier variable del mismo tipo.)
end//

call pr_cuentamitabla(@nregistros);
select @nregistros;

1- Crear tablas menores y adultos con los campos edad y nombre. Crear un procedimiento que si es menor de 18 años inserte en menores y si no en adultos.

#Creacion de las tablas
create table adultos
(
id int(11) auto_increment,
nombre varchar(20),
edad int(3),
primary key (id)
) ENGINE = InnoDB;

create table menores
(
id int(11) auto_increment,
nombre varchar(20),
edad int(3),
primary key (id)
) ENGINE = InnoDB;

#Creacion del procedimiento
create procedure pr_inporedad (IN pnombre varchar(20),IN pedad int(3))
begin
if pedad < 18 then
insert into menores (nombre, edad) values (pnombre, pedad);
else
insert into adultos (nombre, edad) values (pnombre, pedad);
end if;
end//

#Pruebas
call pr_inporedad("Manolo", 17);
call pr_inporedad("Eduardo", 25);

2- Crear la tabla ERROREs con los campos ID, Fecha, CodError. Crear un procedimiento que sume 1 a un parametro, si la suma vale 12 insertar en errores el valor 55555 sino insertar el valor 66666.

#Crear tabla
create table errores
(
id int(11) auto_increment,
nerror int(5),
fecha date,
primary key (id)
)engine = InnoDB;

#Crear procedimiento
create procedure pr_suma (IN pnum INT)
begin
declare v1 int;
set v1 = pnum + 1;
if v1 = 12 then
insert into errores
(nerror, fecha)
values
(55555, current_date());
else
insert into errores
(nerror, fecha)
values
(66666, current_date());
end if;
end//

#Pruebas
call pr_suma(11);
call pr_suma(12);

3- Crear un procedimiento que sume 2 a un parametro, si la suma vale 2 insertará 77777, si vale 3 insertará 88888 y en otro caso 99999.

#Crear el procedimiento
create procedure pr_sima2 (in pnum INT)
begin
set pnum = pnum + 2;

case pnum
when 2 then
insert into errores (nerror, fecha) values (77777, current_date());
when 3 then
insert into errores (nerror, fecha) values (88888, current_date());
else
insert into errores (nerror, fecha) values (99999, current_date());
end case;
end//

#Pruebas
call pr_sima2 (0);
call pr_sima2 (1);
call pr_sima2 (2);

Crear base de datos con ventas y comisiones, con un trigger y un procedure para calcular y actualizar las comisiones que van a cobrar los vendedores

#Creacion de la tabla ventas
create table ventas
(id int(11) auto_increment,
vendedor int(1),
producto int(1),
importe decimal(5,2),
primary key (id)
) ENGINE = InnoDB;

#Creacion de la tabla comisiones
create table comisiones
(vendedor int(1),
comision decimal(6,2),
primary key (vendedor)
) ENGINE = InnoDB;

#Crear el procedimiento para calcular la comision en base al producto
create procedure pr_CalcComision(IN pproducto INT,IN pprecio decimal(5,2), OUT pcomision decimal (6,2))
begin
case pproducto
when 1 then
set pcomision = pprecio * 0.15;
when 2 then
set pcomision = pprecio * 0.10;
when 3 then
set pcomision = pprecio * 0.20;
end case;
end

Crear un trigger que llame a este procedimiento cada vez que se realiza una venta (Insercion en ventas)

create trigger tr_venta
after insert on ventas
for each row
begin
call pr_CalcComision(new.producto,new.importe, @comi);
if (select count(*) from comisiones where vendedor = new.vendedor) = 0 then
insert into comisiones values (new.vendedor, @comi);
else
update comisiones
set comision = comision + @comi
where vendedor = new.vendedor;
end if;
end

#Probar el trigger
insert into ventas
(vendedor, producto, importe)
values
(1,1,50);
insert into ventas
(vendedor, producto, importe)
values
(2,1,50);

MySQL Workbench

Instalar herramienta. (Disponible en la web oficial de MYSQL).
Crear los siguientes procedimientos almacenados desde esta herramienta.

1- Que escriba si dos cadenas son iguales o no.

use pruebas;
#Procedimiento
DELIMITER
create procedure pr_compararcadenas(in cadena1 varchar(100),in cadena2 varchar(100), out resultado varchar(50))
begin
if (select strcmp(cadena1,cadena2)) = 0 then
set resultado = 'Las dos cadenas son iguales';
else
set resultado = 'Las cadenas son diferentes';
end if;
end
#Pruebas
call pr_compararcadenas('hola','hola',@resul);
select @resul;
call pr_compararcadenas('hola','adios',@resul);
select @resul;

2- Que inserte en errores los valores del 0 al 99 (WHILE).

DELIMITER
create procedure pr_inserterrores()
begin
set @x = 1;
while @x < 100 do
insert into errores
(nerror)
values
(@x);
set @x = @x + 1;
end while;
end
#Pruebas
call pr_inserterrores();
select top 99 * from errores order by id DESC;

3- Que inserte en errores los valores desde un parametro hasta el 0 (REPEAT).

create procedure insertardesde(in num int)
begin

REPEAT

insert into errores
(nerror)
values
(num);

SET num = num - 1;

UNTIL num = -1
END REPEAT;

end

Anotaciones

Sintaxis de comprobacion:
check table [nombretabla o vista];
Te comprobara si la tabla existe o no. Y mas cosas.

Sintaxis while:

#Repetir siempre que se cumpla la condicion
while condicion do
ACCIONES;
end while;

Sintaxis repeat:

#Se repetirá hasta que se cumpla la condicion de salida
REPEAT
acciones
UNTIL condicion
END REPEAT;

Funcion IFNULL(Valor_a_evaluar, valor_en_caso_NULL);

#Esta select UNICAMENTE almacenara verdadero en existe en caso un registro en comisiones que pertenezca al vendedor indicado
Declare existe bool;
Select Count(1) > 0 INTO existe from comisiones where vendedor = p_vendedor;
if existe then
acciones;
else
otras acciones;
end if;

Vistas

Similares a las consultas. Guardar una consulta con un nombre, de forma que puedo utilizarla como si fuese una tabla. Nos permite adaptar la informacion que queremos usar.
No se les puede aplicar triggers.

Por ejemplo: Tenemos 5 tablas de las que un usuario tiene que visualizar informacion de cosas concretas. Al usuario no le vamos a dar acceso a la base de datos completa. Podemos realizar una select con los campos que deseamos que pueda ver ese usuario y por medio de la vista que solo pueda acceder a su informacion atraves de ese objeto.

Sintaxis:
#Aconsejable usar un prefijo en el nombre de la vista para su posterior identificacion los corchetes indican que esa parte es opcional
CREATE [or REPLACE]
view NOMBRE [(columnas)]
[ ALGORITHM: {UNDEFINED | MERGE | TEMPORAL} ]
as
select ...;
WITH [ {cascade | local} check option];


*UNDEFINED: Usara merge o temporal a su criterio.
*MERGE: Cuando voy a usar la vista mezcla el texto de la consulta con el de definicion de la vista.
Ejemplo: select importe, producto from V_vendedores where importe > 5000
Aqui V_vendedores se combina con el codigo de la vista.
*TEMPORAL: Realizas una consulta y se crea una tabla temporal que vivirá hasta que devuelva los datos de la consulta de la vista.
*Local: Comprobar un nivel.
*cascade: Comprobar todos los niveles que haya detras.


La posibilidad de modificar los datos de una vista depende del motor de bases de datos que estemos usando:
La mayoria de los motores nos permitiran modificar datos de una vista que viene de una select sin agrupacion.
Con agrupacion no podre modificar ni insertar.
Si llego a la clave de las tablas podre modificar.
No sera actualizable si conteiene: Funcitones agregadas, distinct, distinct row, group by, having, union, subconsulta, aveces JOIN.

Razones para realizar vistas:
-Seguridad.
-Filtrar de manera vertical (Evitar que se acceda a campos innecesarios).
- Muchas veces el esquema de la base de datos no es facil de entender para cualquier persona, esta es una solucion para las personas que no entienden.

Ejercicios Vistas:

1 - para marketing, crear una vista con las ventas de productos acumuladas.

create or replace
algorithm = MERGE
view v_PrAcumulados
as
select lineaspedido.idproducto, productos.descripcion,
sum(lineaspedido.cantidadPedida*lineaspedido.preciounitario - lineaspedido.cantidadPedida*lineaspedido.descuentounitario) as total
from lineaspedido inner join productos on lineaspedido.idproducto = productos.idproducto group by lineaspedido.idproducto;

select * from v_PrAcumulados;

2- Para contabilidad, hacer una vista resumen economico: Cliente, nombre, pedido, Fecha, Total.

create or replace view v_resumeneconomico
as
select clientes.idcliente, clientes.nombre, pedidos.idpedido, pedidos.fechapedido,
sum(lineaspedido.cantidadpedida*lineaspedido.preciounitario - lineaspedido.cantidadPedida*lineaspedido.descuentounitario)
from pedidos inner join lineaspedido
on pedidos.idpedido = lineaspedido.idpedido
inner join clientes
on pedidos.idcliente = clientes.idcliente
group by lineaspedido.idpedido;

select * from v_resumeneconomico;

3- Vista sobre pedidos pero que muestre el nombre del cliente en lugar del ID.

create or replace view v_pedidos
as
select idpedido, clientes.nombre, idtransportista, retorntransportista,
fechapedido, fechaentrega, pedidos.idincoterm, entregado
from clientes inner join pedidos;

select * from v_pedidos;

4- Modificar la vista sobre pedidos para que muestre además el teléfono.

create or replace view v_pedidos
as
select idpedido, clientes.nombre, idtransportista, retorntransportista,
fechapedido, fechaentrega, pedidos.idincoterm, entregado, clientes.telfijo, clientes.telmovil
from clientes inner join pedidos;

select * from v_pedidos;

Ejercicios plataforma vistas

Crear la siguiente base de datos

Marcas(CifM, Nombre, Ciudad)
Coches(CodCoche, Nombre, Modelo)
Concesionarios(CifC, Nombre, Ciudad)
Clientes(Dni, Nombre, Apellidos, Ciudad)
Distribución(CifC, CodCoche, Cantidad)
Ventas(CifC, Dni, CodCoche, Color)
Fabricado(CifM, CodCoche)

#Creacion
create database empresacoches;
use empresacoches;
create table marcas
(cifm varchar(9),
nombre varchar(50),
ciudad varchar(50),
primary key (cifm)
) engine = InnoDB;

create table coches
(codcoche varchar(9),
nombre varchar(50),
modelo varchar(9),
primary key (codcoche)
) engine = InnoDB;

create table fabricado
(cifm varchar(9),
codcoche varchar(9),
primary key (cifm,codcoche),
constraint fk_modelo foreign key (cifm) references marcas(cifm),
constraint fk_coches foreign key (codcoche) references coches(codcoche)
)engine = InnoDB;

create table concesionario
(
cifc varchar(9),
nombre varchar(50),
ciudad varchar(50),
primary key (cifc)
) engine = innodb;

create table distribucion
(cifc varchar(9),
codcoche varchar(9),
cantidad int(5),
primary key (cifc,codcoche),
constraint fk_d_concesionarios foreign key (cifc) references concesionario(cifc),
constraint fk_d_coches foreign key (codcoche) references coches(codcoche)
) engine = innodb;

create table clientes
(dni varchar(9),
nombre varchar(25),
apellidos varchar(25),
ciudad varchar(50),
primary key (dni)
) engine = innodb;

#Pendiente de acabar
create table ventas
(cifc varchar(9),
dni varchar(9),
codcoche varchar(9),
color varchar(25),
primary key (cifc,dni,codcoche),
constraint fk_v_coches foreign key (codcoche) references coches(codcoche),
constraint fk_v_clientes foreign key (dni) references clientes(dni),
constraint fk_v_concesionario foreign key (cifc) references concesionario(cifc)
) engine = innodb;

Se pide:

a) Obtener una vista con los códigos de coches que hayan sido adquiridos por un cliente de Madrid a un concesionario de Madrid.

create or replace
algorithm = merge
view vista1
as select ventas.codcoche
from ventas inner join concesionario
on ventas.cifc = concesionario.cifc
inner join clientes
on ventas.dni = clientes.dni
where clientes.ciudad like "madrid"
and concesionario.ciudad like "madrid";

b) Obtener una vista con el DNI de los clientes que han comprado algún coche a un concesionario de Madrid.

create or replace
algorithm = merge
view vista2
as select ventas.dni
from ventas inner join concesionario
on ventas.cifc = concesionario.cifc
where concesionario.ciudad like "madrid";

c) Obtener una vista con el nombre y apellido de los clientes cuyo Dni es menor que el del cliente Juan Martín Martín.

create or replace
algorithm = merge
view vista3
as select nombre & " " & apellidos from clientes
where dni < (select dni from clientes where nombre & " " & apellidos like "Juan Martín Martín");

d) Obtener una vista con el nombre y el apellido cuyo Dni es menor que el de los clientes de Barcelona.

create or replace
algorithm = merge
view vista4
as select nombre & " " & apellidos from clientes
where dni < (select max(dni) from clientes group by ciudad having ciudad like "barcelona")

e) Obtener una vista con el nombre y los apellidos de los clientes que han comprado como mínimo un coche blanco y otro rojo.

create or replace
algorithm = merge
view vista5
as
select dni
from clientes
where dni in (
select dni
from ventas
where color like "blanco"
group by dni
having count(dni) > 0)
and dni in (
select dni
from ventas
where color like "rojo"
group by dni
having count(dni) > 0)

f) Obtener una vista con el Dni de los clientes cuya ciudad sea la última de la lista alfabética de las ciudades donde hay concesionarios.

create or replace
algorithm = merge
view vista6
as
select dni
from clientes
where ciudad in (select ciudad from concesionario order by ciudad desc);

g) Obtener una vista con el CifC del concesionario que no sea de Madrid cuya media de vehículos en stock sea la más alta de todas las medias.

create or replace
algorithm = merge
view vista7
as
select distribucion.cifc
from distribucion inner join concesionario
on distribucion.cifc = concesionario.cifc
where concesionario.ciudad not like "madrid"
group by distribucion.cifc
having avg(cantidad) = (select top 1 avg(cantidad) from distribucion group by cifc order by avg(cantidad) desc);

h) Obtener una vista con el CodC de los coches vendidos por algún concesionario de Madrid.

create or replace
algorithm = merge
view vista8
as
select ventas.codcoche
from ventas inner join concesionario
on ventas.cifc = concesionario.cifc
where concesionario.ciudad like "madrid"

i) Obtener una vista con los Dni de los clientes que sólo han comprado coches al concesionario 0001.

create or replace
algorithm = merge
view vista9
as
select distinct dni
from ventas
where cifc like "0001"

j) Obtener una vista con el CifC de los concesionarios que han vendido el mismo coche a todos los clientes.

create or replace
algorithm = merge
view vista10
as
select cifc, codcoche
from ventas
group by cifc,codcoche
having count(distinct dni) = (select count(*) from clientes);

Usuarios en MYSQL

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.
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.
De tabla: se aplican a tablas individuales, y por lo tanto, a todas las columnas de esas tabla.
De columna: se aplican a una columna en una tabla concreta.
De rutina: se aplican a los procedimientos almacenados. Aún no hemos visto nada sobre este tema, pero en MySQL se pueden almacenar procedimietos consistentes en varias consultas SQL.

Creacion de usuarios

Aunque en la versión 5.0.2 de MySQL existe una sentencia para crear usuarios, , en versiones anteriores se usa exclusivamente la sentencia para crearlos.
En general es preferible usar , ya que si se crea un usuario mediante , posteriormente hay que usar una sentencia para concederle privilegios.
Usando podemos crear un usuario y al mismo tiempo concederle también los privilegios que tendrá. La sintaxis simplificada que usaremos para , sin preocuparnos de temas de cifrados seguros que dejaremos ese tema para capítulos avanzados, es:

GRANT priv_type [(column_list)] [, priv_type [(column_list)]] ...
    ON {tbl_name | * | *.* | db_name.*}
    TO user [IDENTIFIED BY [PASSWORD] 'password']
        [, user [IDENTIFIED BY [PASSWORD] 'password']] ...

La primera parte priv_type [(column_list)] permite definir el tipo de privilegio concedido para determinadas columnas. La segunda ON {tbl_name | * | *.* | db_name.*}, permite conceder privilegios en niveles globales, de base de datos o de tablas.
Para crear un usuario sin privilegios usaremos la sentencia:

mysql> GRANT USAGE ON *.* TO anonimo IDENTIFIED BY 'clave';
Query OK, 0 rows affected (0.02 sec)

Hay que tener en cuenta que la constraseña se debe introducir entre comillas de forma obligatoria.
Un usuario 'anonimo' podrá abrir una sesión MySQL mediante una orden:

C:\mysql -h localhost -u anonimo -p

Pero no podrá hacer mucho más, ya que no tiene privilegios. No tendrá, por ejemplo, oportunidad de hacer selecciones de datos, de crear bases de datos o tablas, insertar datos, etc.

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 de una tabla concreta. Esto se haría así:
La misma sentencia se usa para añadir privilegios a un usuario existente.

mysql> GRANT SELECT ON prueba.gente TO anonimo;
Query OK, 0 rows affected (0.02 sec)

Esta sentencia concede al usuario 'anonimo' el privilegio de ejecutar sentencias sobre la tabla 'gente' de la base de datos 'prueba'.
Un usuario que abra una sesión y se identifique como 'anonimo' podrá ejecutar estas sentencias:

mysql> SHOW DATABASES;
+----------+
| Database |
+----------+
| prueba   |
+----------+
1 row in set (0.01 sec)
 
mysql> USE prueba;
Database changed
mysql> SHOW TABLES;
+------------------+
| Tables_in_prueba |
+------------------+
| gente            |
+------------------+
1 row in set (0.00 sec)
 
mysql> SELECT * FROM gente;
+----------+------------+
| nombre   | fecha      |
+----------+------------+
| Fulano   | 1985-04-12 |
| Mengano  | 1978-06-15 |
| Tulano   | 2001-12-02 |
| Pegano   | 1993-02-10 |
| Pimplano | 1978-06-15 |
| Frutano  | 1985-04-12 |
+----------+------------+
6 rows in set (0.05 sec)
 
mysql>

Como se ve, para este usuario sólo existe la base de datos 'prueba' y dentro de esta, la tabla 'gente'. Además, podrá hacer consultas 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 usa ON *.*, para indicar que los privilegios se conceden en todas las tablas de todas las bases de datos.
Para conceder privilegios en bases de datos se usa ON nombre_db.*, indicando que los privilegios se conceden sobre todas las tablas de la base de datos 'nombre_db'.
Usando ON nombre_db.nombre_tabla, concedemos privilegios de nivel de tabla para la tabla y base de datos especificada.
En cuanto a los privilegios de columna, para concederlos se usa la sintaxis tipo_privilegio (lista_de_columnas), [tipo_privilegio (lista_de_columnas)].
Otros privilegios que se pueden conceder son:

• ALL: para conceder todos los privilegios.
• CREATE: permite crear nuevas tablas.
• DELETE: permite usar la sentencia .
• DROP: permite borrar tablas.
• INSERT: permite insertar datos en tablas.
• UPDATE: permite usar la sentencia .

Para ver una lista de todos los privilegios existentes consultar la sintaxis de la sentencia .
Se pueden conceder varios privilegios en una única sentencia. Por ejemplo:

mysql> GRANT SELECT, UPDATE ON prueba.gente TO anonimo IDENTIFIED BY 'clave';
Query OK, 0 rows affected (0.22 sec)
 
mysql>

Un detalle importante es que para crear usuarios se debe tener el privilegio GRANT OPTION, y que sólo se pueden conceder privilegios que se posean.

Revocar privilegios

Para revocar privilegios se usa la sentencia .

REVOKE priv_type [(column_list)] [, priv_type [(column_list)]] ...
    ON {tbl_name | * | *.* | db_name.*}
    FROM user [, user] ...

La sintaxis es similar a la de , por ejemplo, para revocar el privilegio SELECT de nuestro usuario 'anonimo', usaremos la sentencia:

mysql> REVOKE SELECT ON prueba.gente FROM anonimo;
Query OK, 0 rows affected (0.05 sec)

Mostrar privilegios

Podemos ver qué privilegios se han concedido a un usuario mediante la sentencia . La salida de esta sentencia es una lista de sentencias que se deben ejecutar para conceder los privilegios que tiene el usuario. Por ejemplo:

mysql> SHOW GRANTS FOR anonimo;
+--------------------------------------------------------------------+
| Grants for anonimo@%                                               |
+--------------------------------------------------------------------+
| GRANT USAGE ON *.* TO 'anonimo'@'%' IDENTIFIED BY PASSWORD '*5...' |
| GRANT SELECT ON `prueba`.`gente` TO 'anonimo'@'%'                  |
+--------------------------------------------------------------------+
2 rows in set (0.00 sec)
 
mysql>

Nombres de usuario y contraseñas

Como podemos ver por la salida de la sentencia , 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 lo indica usando el comodín '%' para el nombre de la máquina.
Si creamos un usuario para una máquina o conjunto de máquinas determinado, ese usuario no podrá conectar desde otras máquinas. Por ejemplo:

mysql> GRANT USAGE ON * TO anonimo@localhost IDENTIFIED BY 'clave';
Query OK, 0 rows affected (0.00 sec)

Un usuario que se identifique como 'anonimo' sólo podrá entrar desde el mismo ordenador donde se está ejecutando el servidor.
En este otro ejemplo:

mysql> GRANT USAGE ON * TO anonimo@10.28.56.15 IDENTIFIED BY 'clave';
Query OK, 0 rows affected (0.00 sec)

El usuario 'anonimo' sólo puede conectarse desde un ordenador cuyo IP sea '10.28.56.15'.
Aunque asignar una constraseña es opcional, por motivos de seguridad es recomendable asignar siempre una.
La contraseña se puede escribir entre comillas simples cuando se crea un usuario, o se puede usar la salida de la función PASSWORD() de forma literal, para evitar enviar la clave en texto legible.
Si al añadir privilegios se usar una clave diferente en la cláusula IDENTIFIED BY, sencillamente se sustituye la contraseña por la nueva.

Borrar usuarios

Para eliminar usuarios se usa la sentencia .
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
mysql>

Para eliminar el usuario primero hay que revocar todos sus privilegios:

mysql> SHOW GRANTS FOR anonimo;
+--------------------------------------------------------------------+
| Grants for anonimo@%                                               |
+--------------------------------------------------------------------+
| GRANT USAGE ON *.* TO 'anonimo'@'%' IDENTIFIED BY PASSWORD '*5...' |
| GRANT SELECT ON `prueba`.`gente` TO 'anonimo'@'%'                  |
+--------------------------------------------------------------------+
2 rows in set (0.00 sec)
 
mysql> REVOKE SELECT ON prueba.gente FROM anonimo;
Query OK, 0 rows affected (0.00 sec)
 
mysql> DROP USER anonimo;
Query OK, 0 rows affected (0.00 sec)
 
mysql>

Pruebas

Creo un usuario llamado barquillos

CREATE USER 'barquillos' IDENTIFIED BY 'mipass';

Crear un usuario asignandole permisos sobreconcesionario.

grant usage on concesionario.* to usuprueba identified by 'contra';

Prueba a logear como ese usuario

mysql.exe -h localhost -u usuprueba -p

Veo que no tengo acceso a concesionario

show databases;

Entro como root a mysql y ejecuto la siguiente consulta para darle permisos a usuprueba sobre empresacoches

grant all privileges on empresacoches to usuprueba;

Probare a dar permisos de select a usuprueba sobre una tabla concreta, solo de visualizacion (lo hare logeado como root)

use colegio;
grant select on colegio.alumno to usuprueba;

Voy a probar a darle permisos de insercion sobre la misma tabla

use colegio;
grant insert on colegio.alumno to usuprueba;

Voy a visualizar los permisos que tiene este usuario

show grants for usuprueba;
#Aqui podemos observar como aun habiendo asignado los permisos en momentos diferentes uno no pisa al otro (select e insert).

Agregamos un trigger a la tabla para ver si el usuario sin permisos la hace funcionar

delimiter
create trigger tr_pruebaalu
after insert on alumno
for each row
begin
update alumno set nombre = 'trigeeeeer' where dni = '3324d';
end

Ahora logeamos como usuprueba para ver si al realizar el insert salta el trigger

Al probar a insertar un registro recibimos el siguiente error. Ni nuestra insert ni la del trigger se llevan acabo.
mysql> insert into alumno (dni, nombre) values ('24234f','webaaaa');
ERROR 1442 (HY000): Can't update table 'alumno' in stored function/trigger beca
se it is already used by statement which invoked this stored function/trigger.

Probaremos a borrar el trigger y realizar una insercion

Drop trigger pruebaalu;
insert into alumno (dni,nombre) values ('3324d','asdasdas');
La insercion se realiza correctamente
He modificado el trigger, en vez de realizar un borrado al insertar he probado a actualizar, pero tampoco,pienso que deberia de tener permisos totales sobre la tabla o de las acciones que hace el trigger.
Asignandole privilegios totales sobre la tabla sigue insultandome con mensajes del trigger

Visualizar los permisos de usuprueba

show grants for usuprueba;

Quitar los permisos a un usuario sobre una tabla

revoke all privileges on empresacoches.concesionario from usuprueba;

Borrar usuario

drop user usuprueba.

Importacion de datos (migrar de un sistema a otro)

Dependiendo del sistema de los datos, como esten en los datos, la plataforma, el modelo.
Si no es posible hacerlo de manera normal, hay que hacerlo a pelo.

Normal:

Exportacion directa.

A pelo:

Sacar informacion a fichero plano y luego importar. Puede que tengamos que limpiar el codigo inecesario del fichero plano.
En las importaciones hay cosas que dan problemas como las fechas.
Por ejemplo:
Puedo tener mi informacion entre excel, access y un fichero plano.

Opcion 1

Migrar cada una directamente.

Opcion 2

Migrar todo a un fichero fichero plano antes de migrar a la base de datos a la que queremos.

Opcion 3

Caracteristicas

En los ficheros planos puedo tener delimitadores o separacion por espacios determinados.
Una migracion puede llevar meses de trabajo.

Como importar

load data [LOCAL] INFILE 'nombre de archivo.txt' Local significa que el fichero esta en mi equipo
[REPLACE | IGNORE] REPLACE: Si encuentra una clave en la que el registro a cambiado lo modifica, con IGNORE lo ignora. (Solo si ya existe)
INTO TABLE nombre_de_tabla
[ FIELDS
[ TERMINATED BY '\t'] Como distingimos el comienzo y y final columna COMO SEPARADOR, los tipicos son "," o ";"
[[OPTIONALLY] ENCLOSED BY 'O'] Los signos que marcan el inicio y cierre de un campo, para IDENTIFICAR EL CAMPO	[ ESCAPED BY '\\'] ] Para saltar un signo		[ LINES [STARTING BY 'O'] [TERMINATED BY '\n']] Marca el comienzo y el final de la linea
[ IGNORE numero LINES] Cuantas lineas del comienzo del fichero no son datos y quiero que las ignore
[ (nombrecolumnas, ... )]] Esto es necesario cuando el numero de columnas de la tabla y del fichero son diferentes o cuando estan desordenados.;

Primera importacion:

create database importando;
use importando;

create table clientes
(idcliente varchar(5),
nombrecompania varchar(40),
nombrecontacto varchar(30),
sexo varchar(1),
cargocontacto varchar(30),
direccion varchar(60),
ciudad varchar(15),
region varchar(15),
codpostal varchar(10),
pais varchar(15),
telefono varchar(24),
fax varchar(24),
primary key (idcliente));

#Importar archivo que esta en misdocumentos llamado clientes2.txt
C:\Users\barquillos\Documents\Clientes2.txt

load data local infile 'C:/Users/barquillos/Documents/Clientes2.txt'

into table clientes

fields

terminated by '\;'

optionally enclosed by '"'

escaped by '\\'

lines terminated by '\n';

Segunda importacion: Importar dos tablas de access (pedidos y detalles pedidos) y que en MYSQL queden en una sola tabla

#Tabla de pedidos
create table pedidos
(
idpedido int(11) auto_increment,
idcliente varchar(5),
idempleado int(9),
fechapedido date,
fechaentrega date,
fechaenvio date,
formaenvio int(9),
cargo float(6,2),
destinatario varchar(40),
direcciondestino varchar(60),
ciudaddestino varchar(15),
regiondestino varchar(15),
codpostaldestino varchar(10),
paisdestino varchar(15),
primary key (idpedido)
) engine = innodb;

#Importacion tabla de pedidos
load data local infile 'C:/Users/barquillos/Documents/db2/pedidos_z.txt'
into table pedidos
fields
terminated by '\;'
optionally enclosed by '"'
escaped by '\\'
lines terminated by '\n\r';

#Creacion de tabla de detalles pedido
create table detallespedido
(idpedido int(11),
idproducto int(11),
PrecioUnidad float(6,2),
Cantidad int(5),
descuento int(3),
primary key (idpedido,idproducto),
constraint fk_pedido foreign key (idpedido) references pedidos(idpedido)
) engine = innodb;

#Importacion de detalles pedidos
load data local infile 'C:/Users/barquillos/Documents/db2/detallespedido_z.txt'
into table detallespedido
fields
terminated by '\;'
optionally enclosed by '"'
escaped by '\\'
lines terminated by '\n\r';

#Juntando las tablas

http://html-color-codes.info/codigos-de-colores-hexadecimales/

---

000000	000020	000040	000060	000080	0000a0	0000c0	0000ff
002000	002020	002040	002060	002080	0020a0	0020c0	0020ff
004000	004020	004040	004060	004080	0040a0	0040c0	0040ff
006000	006020	006040	006060	006080	0060a0	0060c0	0060ff
008000	008020	008040	008060	008080	0080a0	0080c0	0080ff
00a000	00a020	00a040	00a060	00a080	00a0a0	00a0c0	00a0ff
00c000	00c020	00c040	00c060	00c080	00c0a0	00c0c0	00c0ff
00ff00	00ff20	00ff40	00ff60	00ff80	00ffa0	00ffc0	00ffff

200000	200020	200040	200060	200080	2000a0	2000c0	2000ff
202000	202020	202040	202060	202080	2020a0	2020c0	2020ff
204000	204020	204040	204060	204080	2040a0	2040c0	2040ff
206000	206020	206040	206060	206080	2060a0	2060c0	2060ff
208000	208020	208040	208060	208080	2080a0	2080c0	2080ff
20a000	20a020	20a040	20a060	20a080	20a0a0	20a0c0	20a0ff
20c000	20c020	20c040	20c060	20c080	20c0a0	20c0c0	20c0ff
20ff00	20ff20	20ff40	20ff60	20ff80	20ffa0	20ffc0	20ffff

400000	400020	400040	400060	400080	4000a0	4000c0	4000ff
402000	402020	402040	402060	402080	4020a0	4020c0	4020ff
404000	404020	404040	404060	404080	4040a0	4040c0	4040ff
406000	406020	406040	406060	406080	4060a0	4060c0	4060ff
408000	408020	408040	408060	408080	4080a0	4080c0	4080ff
40a000	40a020	40a040	40a060	40a080	40a0a0	40a0c0	40a0ff
40c000	40c020	40c040	40c060	40c080	40c0a0	40c0c0	40c0ff
40ff00	40ff20	40ff40	40ff60	40ff80	40ffa0	40ffc0	40ffff

600000	600020	600040	600060	600080	6000a0	6000c0	6000ff
602000	602020	602040	602060	602080	6020a0	6020c0	6020ff
604000	604020	604040	604060	604080	6040a0	6040c0	6040ff
606000	606020	606040	606060	606080	6060a0	6060c0	6060ff
608000	608020	608040	608060	608080	6080a0	6080c0	6080ff
60a000	60a020	60a040	60a060	60a080	60a0a0	60a0c0	60a0ff
60c000	60c020	60c040	60c060	60c080	60c0a0	60c0c0	60c0ff
60ff00	60ff20	60ff40	60ff60	60ff80	60ffa0	60ffc0	60ffff

800000	800020	800040	800060	800080	8000a0	8000c0	8000ff
802000	802020	802040	802060	802080	8020a0	8020c0	8020ff
804000	804020	804040	804060	804080	8040a0	8040c0	8040ff
806000	806020	806040	806060	806080	8060a0	8060c0	8060ff
808000	808020	808040	808060	808080	8080a0	8080c0	8080ff
80a000	80a020	80a040	80a060	80a080	80a0a0	80a0c0	80a0ff
80c000	80c020	80c040	80c060	80c080	80c0a0	80c0c0	80c0ff
80ff00	80ff20	80ff40	80ff60	80ff80	80ffa0	80ffc0	80ffff

a00000	a00020	a00040	a00060	a00080	a000a0	a000c0	a000ff
a02000	a02020	a02040	a02060	a02080	a020a0	a020c0	a020ff
a04000	a04020	a04040	a04060	a04080	a040a0	a040c0	a040ff
a06000	a06020	a06040	a06060	a06080	a060a0	a060c0	a060ff
a08000	a08020	a08040	a08060	a08080	a080a0	a080c0	a080ff
a0a000	a0a020	a0a040	a0a060	a0a080	a0a0a0	a0a0c0	a0a0ff
a0c000	a0c020	a0c040	a0c060	a0c080	a0c0a0	a0c0c0	a0c0ff
a0ff00	a0ff20	a0ff40	a0ff60	a0ff80	a0ffa0	a0ffc0	a0ffff

c00000	c00020	c00040	c00060	c00080	c000a0	c000c0	c000ff
c02000	c02020	c02040	c02060	c02080	c020a0	c020c0	c020ff
c04000	c04020	c04040	c04060	c04080	c040a0	c040c0	c040ff
c06000	c06020	c06040	c06060	c06080	c060a0	c060c0	c060ff
c08000	c08020	c08040	c08060	c08080	c080a0	c080c0	c080ff
c0a000	c0a020	c0a040	c0a060	c0a080	c0a0a0	c0a0c0	c0a0ff
c0c000	c0c020	c0c040	c0c060	c0c080	c0c0a0	c0c0c0	c0c0ff
c0ff00	c0ff20	c0ff40	c0ff60	c0ff80	c0ffa0	c0ffc0	c0ffff

ff0000	ff0020	ff0040	ff0060	ff0080	ff00a0	ff00c0	ff00ff
ff2000	ff2020	ff2040	ff2060	ff2080	ff20a0	ff20c0	ff20ff
ff4000	ff4020	ff4040	ff4060	ff4080	ff40a0	ff40c0	ff40ff
ff6000	ff6020	ff6040	ff6060	ff6080	ff60a0	ff60c0	ff60ff
ff8000	ff8020	ff8040	ff8060	ff8080	ff80a0	ff80c0	ff80ff
ffa000	ffa020	ffa040	ffa060	ffa080	ffa0a0	ffa0c0	ffa0ff
ffc000	ffc020	ffc040	ffc060	ffc080	ffc0a0	ffc0c0	ffc0ff
ffff00	ffff20	ffff40	ffff60	ffff80	ffffa0	ffffc0	ffffff