actividada 19

preguntas

1. contestar lo siguiente y publique en su blog Viernes 25 de Octubre
1. ¿Qué es una transacción?

es capaz de mantener la integridad de los datos, haciendo que estas transacciones no puedan finalizar en un estado intermedio. Cuando por alguna causa el sistema debe cancelar la transacción, empieza a deshacer las órdenes ejecutadas hasta dejar la base de datos en su estado inicial (llamado punto de integridad), como si la orden de la transacción nunca se hubiese realizado

 

 

2. ¿Qué significa ACID? y defina cada una de las palabras que forman las siglas

En bases de datos se denomina ACID a un conjunto de características necesarias para que una serie de instrucciones puedan ser consideradas como una transacción. Así pues, si un sistema de gestión de bases de datos es ACID compliant quiere decir que el mismo cuenta con las funcionalidades necesarias para que sus transacciones tengan las características ACID.

      En concreto ACID es un acrónimo de Atomicity, Consistency, Isolation and Durability:              Atomicidad, Consistencia, Aislamiento y Durabilidad en español.

 

3. ¿Qué significa Tx?

 

4. ¿Para que nos sirve el Rollback?

                      es una operación que devuelve a la base de datos a algún estado previo

En SQL, ROLLBACK es un comando que causa que todos los cambios de datos desde la última sentencia BEGIN WORK, o START TRANSACTION sean descartados por el sistema de gestión de base de datos relacional (RDBMS), para que el estado de los datos sea "rolled back"(devuelto) a la forma en que estaba antes de que aquellos cambios tuvieran lugar

 

 

 

 

5. defina Integridad de datos

se refiere a la corrección y complementación de los datos en una base de datos. Cuando los contenidos se modifican con sentencias INSERT, DELETE o UPDATE, la integridad de los datos almacenados puede perderse de muchas maneras diferentes. Pueden añadirse datos no válidos a la base de datos, tales como un pedido que especifica un producto no existente.

 

6. defina concurrencia

El control de accesos concurrentes y específicamente de transacciones concurrentes es manejado por un módulo del dbms llamado "scheduler".

 

7. Defina Grado de consistencia

 

 

 8.Mencione aspectos relacionados al procesamiento de transacciones

Los sistemas distribuidos son muy confiables debido a la posibilidad de brindar redundancia y autonomía de recursos en diferentes nodos, esto posibilita detectar y localizar fallas, sin embargo tenemos varios aspectos que representan problemas para la integridad de los recursos y que a su vez motivan el uso de transacciones

 

<Dificultad para mantener consistencia en los datos

<Una misma vía de comunicación no siempre puede ser utilizada para suministrar interacción entre dos procesos

<Requerimientos de procesamientos en paralelo

<Manejo interactivo de uno o mas usuarios

 

 

9. defina los estados de una transacción

Activa (estado inicial): la transacción permanece en este estado durante su ejecución.

Parcialmente Comprometida: la transacción pasa a este estado cuando acaba de realizar la última instrucción.

Fallida: la transacción pasa a este estado tras descubrir que no puede continuar la ejecución normal.

Abortada: la transacción pasa a este estado después de haber restablecido la base de datos a su estado anterior.

Comprometida: la transacción pasa a este estado tras completarse con éxito

 

10.   El estándar ANSI/ISO SQL define cuatro niveles de aislamiento transaccional en función de tres eventos que son permitidos o no dependiendo del nivel de aislamiento. Estos eventos son

 

 

·         Controla si se realizan bloqueos cuando se leen los datos y qué tipos de bloqueos se solicitan.

·         Duración de los bloqueos de lectura.

·         Si una operación de lectura que hace referencia a filas modificadas por otra transacción:

o    Se bloquea hasta que se libera el bloqueo exclusivo de la fila.

o    Recupera la versión confirmada de la fila que existía en el momento en el que empezó la instrucción o la transacción.

o    Lee la modificación de los datos no confirmados.

 

 

actividad 20

DBMS


Es un sistema robusto que es capaz de emplear algoritmos de almacenamiento y recuperación de información para poder implementar un modelo de datos de manera física garantizando que todas las transacciones que se realizan con respecto a dichos datos sean "ácidas" (Atomicity, Consistency, Isolation, Duration).

 Las partes utilizadas para ejemplificar la arquitectura se refieren a Oracle

Una base de datos en ejecución consta de 3 cosas:

• Archivos
  • Control (ctl): almacenan información acerca de la estructura de archivos de la base.
  • Rollback (rbs): cuando se modifica el valor de alguna tupla en una transacción, los valores nuevos y anteriores se almacenan en un archivo, de modo que si ocurre algún error, se puede regresar (rollback) a un estado anterior.
  • Redo (rdo): bitácora de toda transacción, en muchos dbms incluye todo tipo de consulta incluyendo aquellas que no modifican los datos.
  • Datos (dbf): el tipo más común, almacena la información que es accesada en la base de datos.
  • Indices (dbf) (dbi): archivos hermanos de los datos para acceso rápido.
  • Temp (tmp): localidades en disco dedicadas a operaciones de ordenamiento o alguna actividad particular que requiera espacio temporal adicional.
• Memoria
  • Shared Global Area (SGA): es el área más grande de memoria y quizás el más importante
    • Shared Pool: es una caché que mejora el rendimiento ya que almacena parte del diccionario de datos y el parsing de algunas consultas en SQL
    • Redo Log Buffer: contiene un registro de todas las transacciones dentro de la base, las cuales se almacenan en el respectivo archivo de Redo y en caso de siniestro se vuelven a ejecutar aquellos cambios que aún no se hayan reflejado en el archivo de datos (commit).
    • Large Pool: espacio adicional, generalmente usado en casos de multithreading y esclavos de I/O.
    • Java Pool: usado principalmente para almacenar objetos Java
  • Program Global Area (PGA): información del estado de cursores/apuntadores
  • User Global Area(UGA): información de sesión, espacio de stack
• Procesos
  • Threading
  • System Monitor: despierta periódicamente y realiza algunas actividades entre las que se encuentran la recuperación de errores, recuperación de espacio libre en tablespaces y en segmentos temporales.
  • Process Monitor: limpia aquellos procesos que el usuario termina de manera anormal, verificando consistencias, liberación de recursos, bloqueos.
  • Database Writer: escribe bloques de datos modificados del buffer al disco, aquellas transacciones que llegan a un estado de commit.
  • Log Writer: escribe todo lo que se encuentra en el redo log buffer hacia el redo file
  • Checkpoint: sincroniza todo lo que se tenga en memoria, con sus correspondientes archivos en disco

Tablas de administración del dbms

(root) [mysql]> desc user; +-----------------------+-----------------------------------+-------------------+------+-----+---------+-------+ | Field | Type | Collation | Null | Key | Default | Extra | +-----------------------+-----------------------------------+-------------------+------+-----+---------+-------+ | Host | varchar(60) binary | binary | | PRI | | | | User | varchar(16) binary | binary | | PRI | | | | Password | varchar(45) binary | binary | | | | | | Select_priv | enum('N','Y') | latin1_swedish_ci | | | N | | | Insert_priv | enum('N','Y') | latin1_swedish_ci | | | N | | | Update_priv | enum('N','Y') | latin1_swedish_ci | | | N | | | Delete_priv | enum('N','Y') | latin1_swedish_ci | | | N | | | Create_priv | enum('N','Y') | latin1_swedish_ci | | | N | | | Drop_priv | enum('N','Y') | latin1_swedish_ci | | | N | | | Reload_priv | enum('N','Y') | latin1_swedish_ci | | | N | | | Shutdown_priv | enum('N','Y') | latin1_swedish_ci | | | N | | | Process_priv | enum('N','Y') | latin1_swedish_ci | | | N | | | File_priv | enum('N','Y') | latin1_swedish_ci | | | N | | | Grant_priv | enum('N','Y') | latin1_swedish_ci | | | N | | | References_priv | enum('N','Y') | latin1_swedish_ci | | | N | | | Index_priv | enum('N','Y') | latin1_swedish_ci | | | N | | | Alter_priv | enum('N','Y') | latin1_swedish_ci | | | N | | | Show_db_priv | enum('N','Y') | latin1_swedish_ci | | | N | | | Super_priv | enum('N','Y') | latin1_swedish_ci | | | N | | | Create_tmp_table_priv | enum('N','Y') | latin1_swedish_ci | | | N | | | Lock_tables_priv | enum('N','Y') | latin1_swedish_ci | | | N | | | Execute_priv | enum('N','Y') | latin1_swedish_ci | | | N | | | Repl_slave_priv | enum('N','Y') | latin1_swedish_ci | | | N | | | Repl_client_priv | enum('N','Y') | latin1_swedish_ci | | | N | | | ssl_type | enum('','ANY','X509','SPECIFIED') | latin1_swedish_ci | | | | | | ssl_cipher | blob | binary | | | | | | x509_issuer | blob | binary | | | | | | x509_subject | blob | binary | | | | | | max_questions | int(11) unsigned | binary | | | 0 | | | max_updates | int(11) unsigned | binary | | | 0 | | | max_connections | int(11) unsigned | binary | | | 0 | | +-----------------------+-----------------------------------+-------------------+------+-----+---------+-------+ 31 rows in set (0.00 sec) (root) [mysql]> desc db; +-----------------------+-----------------+-------------------+------+-----+---------+-------+ | Field | Type | Collation | Null | Key | Default | Extra | +-----------------------+-----------------+-------------------+------+-----+---------+-------+ | Host | char(60) binary | binary | | PRI | | | | Db | char(64) binary | binary | | PRI | | | | User | char(16) binary | binary | | PRI | | | | Select_priv | enum('N','Y') | latin1_swedish_ci | | | N | | | Insert_priv | enum('N','Y') | latin1_swedish_ci | | | N | | | Update_priv | enum('N','Y') | latin1_swedish_ci | | | N | | | Delete_priv | enum('N','Y') | latin1_swedish_ci | | | N | | | Create_priv | enum('N','Y') | latin1_swedish_ci | | | N | | | Drop_priv | enum('N','Y') | latin1_swedish_ci | | | N | | | Grant_priv | enum('N','Y') | latin1_swedish_ci | | | N | | | References_priv | enum('N','Y') | latin1_swedish_ci | | | N | | | Index_priv | enum('N','Y') | latin1_swedish_ci | | | N | | | Alter_priv | enum('N','Y') | latin1_swedish_ci | | | N | | | Create_tmp_table_priv | enum('N','Y') | latin1_swedish_ci | | | N | | | Lock_tables_priv | enum('N','Y') | latin1_swedish_ci | | | N | | +-----------------------+-----------------+-------------------+------+-----+---------+-------+ (root) [mysql]> insert into user (host,user,password) values ('%','carlos',password('lolo')); Query OK, 1 row affected (0.07 sec) (root) [mysql]> select * from user where user='carlos'; +------+--------+-----------------------------------------------+-------------+-------------+-------------+-------------+ | Host | User | Password | Select_priv | Insert_priv | Update_priv | Delete_priv | +------+--------+-----------------------------------------------+-------------+-------------+-------------+-------------+ | % | carlos | *87f0212af7420ce3e0b2b8992eb42dda4be54c9125b3 | N | N | N | N | +------+--------+-----------------------------------------------+-------------+-------------+-------------+-------------+ 1 row in set (0.00 sec) (root) [mysql]> create database prueba; Query OK, 1 row affected (0.00 sec) (root) [mysql]> insert into db values ('%','prueba','carlos','Y','Y','Y','Y','Y','Y','Y','Y','Y','Y','Y','Y'); Query OK, 1 row affected (0.00 sec) (root) [mysql]> select * from db where user='carlos'; +------+--------+--------+-------------+-------------+-------------+-------------+ | Host | Db | User | Select_priv | Insert_priv | Update_priv | Delete_priv | +------+--------+--------+-------------+-------------+-------------+-------------+ | % | prueba | carlos | Y | Y | Y | Y | +------+--------+--------+-------------+-------------+-------------+-------------+ 1 row in set (0.09 sec) (root) [mysql]> flush privileges; Query OK, 0 rows affected (0.07 sec)

actividad 18

actividad 18

CREATE table paciente(
    idPaciente varchar(30) primary key,
    nombre varchar(45),
    apellido varchar(45),
    fechaNacimiento Date,
    EstadoCivil varchar(10),
    Profesion varchar(45),
    Telf int,
    sexo char,
    seguroMedico bool
 );

  CREATE table receta(
    idReceta int primary key auto_increment,
    dosis varchar(45),
    preescripcion varchar(45),
    paciente_id int,
    //farmaco_id int,
  
 );
CREATE table farmaco(
 idFarmaco int primary key auto_increment,
 nombre varchar(50),
 notas varchar(150),
 receta_id int,
);


 CREATE table cita(
    idCita int primary key auto_increment,
    fecha DATE,
    notas varchar(200),
    paciente_id int,
 );

 CREATE table consulta(
    idConsulta int primary key auto_increment,
    historiaClinica varchar(200),
    tratamiento varchar(200),
    diagnostico varchar(200),
    paciente_id int,
    foreign key(paciente_id) references Paciente(idPaciente)
 ); CREATE table paciente(
    idPaciente varchar(30) primary key,
    nombre varchar(45),
    apellido varchar(45),
    fechaNacimiento Date,
    EstadoCivil varchar(10),
    Profesion varchar(45),
    Telf int,
    sexo char,
    seguroMedico bool
 );

  CREATE table receta(
    idReceta int primary key auto_increment,
    farmaco_id int primary key auto_increment,
    dosis varchar(45),
    preescripcion varchar(45),
    paciente_id varchar(30),
    farmaco_id int,
 
 );
CREATE table farmaco(
 idFarmaco int primary key auto_increment,
 nombre varchar(50),
 notas varchar(150),
 receta_id int,
);


 CREATE table cita(
    idCita int primary key auto_increment,
    fecha DATE,
    notas varchar(100),
    paciente_id varchar(30),
 );

 CREATE table consulta(
    idConsulta int primary key auto_increment,
    historiaClinica varchar(100),
    tratamiento varchar(100),
    diagnostico varchar(150),
    paciente_id varchar(30),
 );

 select * from paciente;

 insert into paciente values('0911111111', 'Jose', 'Cevallos', '2013-07-01', 'Soltero', 'arquero', '234566', 'M', '1');
 insert into paciente values('0919666818', 'Daniel Andres', 'Paez', '1989-11-04', 'Soltero', 'Estudiante', '2884926', 'M', '0');
insert into paciente values('0921735627', 'Gabriela', 'Game', '1988-06-04', 'Soltero', 'estudiante', '983622669', 'F', '0');
insert into paciente values('0922222222', 'juan', 'perez', '2013-07-01', 'Soltero', 'estudiante', '2222222', 'M', '1');
delimiter //
create procedure nuevoPaciente
(in cedula varchar(30), in nombre varchar(30) , in apellido varchar(30),
in fechaNac date, in estCivil varchar(20),
in prof varchar(30), in telf int, in sexo char, in segMedico bool)
begin
insert into paciente values
(cedula,nombre,apellido,fechaNac,estCivil,prof,telf,sexo,segMedico);
end//
delimiter ;

delimiter //
create procedure BuscarPacientePorCedula
(in cedula varchar(30), out idPaciente varchar(30),  out nombre varchar(30),
out apellido varchar(30),out fechaNacimiento date, out estadoCivil varchar(15),
out profesion varchar(30),out telf int)
begin
select p.idPaciente into idPaciente from paciente p where p.idPaciente = cedula;
select p.nombre into nombre from paciente p where p.idPaciente = cedula;
select p.apellido into apellido from paciente p where p.idPaciente = cedula;
select p.fechaNacimiento into fechaNacimiento from paciente p where p.idPaciente = cedula;
select p.estadoCivil into estadoCivil from paciente p where p.idPaciente = cedula;
select p.profesion into profesion from paciente p where p.idPaciente = cedula;
select p.telf into telf from paciente p where p.idPaciente = cedula;
end//
delimiter ;
call BuscarPacientePorCedula('0919666818',@a,@b,@c,@d,@e,@f,@g);
drop procedure BuscarPacientePorCedula;

delimiter //
create procedure editarPaciente
(in cedula varchar(30), in nombre varchar(30) , in apellido varchar(30),
in fechaNac date, in estCivil varchar(20),
in prof varchar(30), in telf int, in sexo char, in segMedico bool)
begin
update paciente p set p.nombre=nombre,p.apellido=apellido,p.fechaNacimiento=fechaNac,
p.EstadoCivil=estCivil,p.profesion=prof,p.telf=telf,p.sexo=sexo,p.seguroMedico=segMedico
where p.idPaciente=cedula;
end//
delimiter ;
call editarPaciente('0912345678', 'Pepito', 'Paez', '1989-10-10', 'Soltero', 'Estudiante', '2223344', 'M', '0');
delimiter //
create procedure BuscarPacientePorApellido
(in apellidoin varchar(30), out idPaciente varchar(30),  out nombre varchar(30),
out apellido varchar(30),out fechaNacimiento date, out estadoCivil varchar(15),
out profesion varchar(30),out telf int)
begin
select p.idPaciente into idPaciente from paciente p where p.apellido = apellidoin;
select p.nombre into nombre from paciente p where p.apellido = apellidoin;
select p.apellido into apellido from paciente p where p.apellido = apellidoin;
select p.fechaNacimiento into fechaNacimiento from paciente p where p.apellido = apellidoin;
select p.estadoCivil into estadoCivil from paciente p where p.apellido = apellidoin;
select p.profesion into profesion from paciente p where p.apellido = apellidoin;
select p.telf into telf from paciente p where p.apellido = apellidoin;
end//
delimiter ;
delimiter //
create procedure seleccionarPacientePorApellido(in apellidoin varchar(30))
begin
select p.idPaciente,p.nombre,p.apellido from paciente p where p.apellido like concat('%',apellidoin,'%');
end//
delimiter ;
drop procedure BuscarPacientePorApellido;
call seleccionarPacientePorApellido('paez');
select * from paciente;
delete from paciente where idPaciente='998765432';
insert into paciente values('0912345678', 'Pepe', 'Paez', '1989-10-10', 'Soltero', 'Estudiante', '2223344', 'M', '0');


delimiter //
create procedure nuevoFarmaco
(in nombre varchar(50),in notas varchar(150))
begin
insert into farmaco values(farmaco.idFarmaco,nombre,notas,null);
end//
delimiter ;
call nuevoFarmaco('loratadina','para alergias');
select * from farmaco;

delimiter //
create procedure seleccionarFarmacos()
begin
select f.nombre,f.notas from farmaco f;
end//
delimiter ;
call seleccionarFarmacos();

delimiter //
create procedure cargarDatosFarmaco
(in nombre varchar(30),out idf int,out nombreF varchar(30),out notas varchar(150))
begin
select f.idFarmaco into idf from farmaco f where f.nombre = nombre;
select f.nombre into nombreF from farmaco f where f.nombre = nombre;
select f.notas into notas from farmaco f where f.nombre = nombre;
end//
delimiter ;
drop procedure cargarDatosFarmaco;
call cargarDatosFarmaco('alercet',@a,@b);
delimiter //
create procedure editarFarmacos
(in idFarmaco int, in nombre varchar(30), in notas varchar(150))
begin
update farmaco f set f.nombre=nombre, f.notas=notas where f.idFarmaco=idFarmaco;
end//
delimiter ;
drop procedure editarFarmacos;

delimiter //
create procedure seleccionarFarmacos()
begin
select f.idFarmaco,f.nombre,f.notas from farmaco f;
end//
delimiter ;
call seleccionarFarmacos();
drop procedure seleccionarFarmacos;

FARMACO_ID Y PACIENTE_ID EN RECETA FALTA HACERLE FOREIGN KEY

alter table receta drop foreign key paciente_id;
alter table receta drop foreign key farmaco_id;
alter table receta drop primary key, add primary key (idReceta, farmaco_id);
insert into receta values(receta.idReceta,3,'despues del almuerzo','0919666818',1);
insert into receta values(1,2,'despues de la merienda','0919666818',2);



delimiter //
create procedure cargarCitasPorCedula(in cedula varchar(10))
begin
select p.idPaciente,p.nombre,p.apellido,c.fecha,c.hora,c.historialClinico,
c.diagnostico,c.tratamiento
from paciente p inner join cita c on p.idPaciente = c.paciente_id
where p.idPaciente = cedula;
end//
delimiter ;
call cargarCitasPorCedula('0921735627');

delimiter //
create procedure cargarCitasPorFecha(in fechainicio date, in fechafin date)
begin
select p.idPaciente,p.nombre,p.apellido,c.fecha,c.hora,c.historialClinico,
c.diagnostico,c.tratamiento
from paciente p inner join cita c on p.idPaciente = c.paciente_id
where c.fecha between fechainicio and fechafin;
end//
delimiter ;
call cargarCitasPorFecha('2013-08-05','2013-08-06');

alter table cita add column historialClinico varchar(150);
alter table cita add column diagnostico varchar(150);
alter table cita add column tratamiento varchar(150);
drop table consulta;
select * from cita;
update cita set historialClinico='alergias' where idCita=1;
update cita set historialClinico='higado graso' where idCita=2;
update cita set historialClinico='hipertension' where idCita=3;
update cita set diagnostico='estrornudos, tos por acaros' where idCita=1;
update cita set diagnostico='dolor estomacal, gases' where idCita=2;
update cita set diagnostico='mareos y desmayos' where idCita=3;
update cita set tratamiento='vaporizaciones, inyecciones, no comer citricos' where idCita=1;
update cita set tratamiento='no comidas grasosas' where idCita=2;
update cita set tratamiento='bajar el nivel de sal en las comidas'where idCita=3;


delimiter //
create procedure guardarCita
(in fecha date, in paciente_id varchar(30),in hora time,
historialClinico varchar(150),in diagnostico varchar(150), in tratamiento varchar(150))
begin
insert into cita values (cita.idCita,fecha,paciente_id,hora,historialClinico,diagnostico,tratamiento);
end//
delimiter ;

delimiter //
create procedure cargarHistorialClinico(in  cedula varchar(30))
begin
select distinct c.historialClinico, c.diagnostico, c.tratamiento from paciente p,cita c where cedula = c.paciente_id;
end//
delimiter ;


delimiter //
create procedure obtenerIdCita()
begin
select max(idCita) from cita;
end//
delimiter ;

delimiter //
create procedure obtenerIdCitayIdPaciente()
begin
select max(idCita) as numCita,c.paciente_id,p.nombre,p.apellido from cita c,paciente p
where idCita = (select max(idCita) from cita) and c.paciente_id = p.idPaciente;
end//
delimiter ;
drop procedure obtenerIdCitayIdPaciente;
call obtenerIdCitayIdPaciente();

alter table receta add column cita_id int;
alter table farmaco drop column receta_id;
alter table farmaco add column numVecesUsado int;
update farmaco set numVecesUsado = 0 where idFarmaco>0;
update receta set cita_id = 2 where farmaco_id = 2;

delimiter //
create procedure cargarCitasExistentes()
begin
select c.fecha,c.hora,p.nombre,p.apellido from cita c inner join paciente p on c.paciente_id=p.idPaciente;
end//
delimiter ;

delimiter //
create procedure cargarRecetasPorNombre(in nombre varchar(30))
begin
select c.fecha,f.nombre,r.dosis,r.preescripcion from receta r,cita c,farmaco f,paciente p
where (p.nombre like nombre or p.apellido = nombre)
and r.cita_id = c.idCita and r.farmaco_id = f.idFarmaco and p.idPaciente = r.paciente_id;
end//
delimiter ;

delimiter //
create procedure cargarRecetasPorCedula(in cedula varchar(30))
begin
select c.fecha,f.nombre,r.dosis,r.preescripcion from receta r,cita c,farmaco f 
where r.paciente_id = cedula and r.cita_id = c.idCita and r.farmaco_id = f.idFarmaco;
end//
delimiter ;

insert into receta values(receta.idReceta,4,'antes del almuerzo',0911111111,4,2);

delimiter //
create procedure cargarFarmacos()
begin
select idFarmaco,nombre from farmaco order by nombre;
end//
delimiter ;
delimiter //
create procedure masrecetados()
begin
select f.nombre,count(r.farmaco_id) as numveces from farmaco f, receta r
where f.idFarmaco = r.farmaco_id group by f.nombre order by numveces desc limit 10 ;
end//
delimiter ;

ALTER TABLE t ENGINE = INNODB;
ALTER TABLE t ENGINE = MyISAM ;

delimiter //
create trigger vecesFarmaco
after insert on receta
for each row
begin
#if(new.farmaco_id=farmaco.idFarmaco)then
update farmaco
set farmaco.numVecesUsado = farmaco.numVecesUsado + 1 where new.farmaco_id = farmaco.idFarmaco;
#end if;
END;//
delimiter ;

delimiter //
create procedure recetaActual()
begin
select max(idReceta) as idreceta from receta;
end//
delimiter ;CREATE table Farmaco(
 idFarmaco int primary key,
 nombre varchar(50),
 notas varchar(150),
 dosis varchar(45),
 preescripcion varchar(45),
 receta_id int,
);
 CREATE table Receta(
    idReceta int primary key,
    paciente_id int,
);

que es una bitacora ??

Que es una Bitacora

La estructura es ampliamente usada para grabar las modificaciones de la base de datos es la Bitácora, herramienta que permite registrar, analizar detectar y notificar eventos que suceden en cualquier sistemas de informacion utilizado en las organizaciones. La estructura mas ampliamente usada para grabar las modificaciones de la BD.

Cuales son sus funciones

La importancia de las bitácoras es la de recuperar información ante incidentes de seguridad, detección de comportamiento inusual, información para resolver problemas, evidencia legal, es de gran ayuda en las tareas de cómputo forense.

Cada registro de la bitácora escribe una única escritura de base de datos y tiene lo siguiente :

Nombre de la transacción : Nombre de la transacción que realizó la operación de escritura.

Nombre del dato : El nombre único del dato escrito.

Valor antiguo : El valor del dato antes de la escritura.

Valor nuevo : El valor que tendrá el dato después de la escritura.

Es fundamental que siempre se cree un registro en la bitácora cuando se realice una escritura antes de que se modifique la base de datos.

También tenemos la posibilidad de deshacer una modificación que ya se ha escrito en la base de datos, esto se realizará usando el campo del valor antiguo de los registros de la bitácora.

Los registros de la bitácora deben residir en memoria estable como resultado el volumen de datos en la bitácora puede ser exageradamente grande.

Una bitácora puede registrar mucha información acerca de eventos relacionados con el sistema que la genera los cuales pueden ser:

• Fecha y hora.

• Host origen.

• Usuario.

• Actividad realizada.

Ejemplo de una creacion de una bitacora en MySQL

Enseguida plantearé un ejemplo de una bitácora desarrollada para la siguiente base de datos de MySQL, llamada proyecto, que tiene las tablas carrera, departamento y maestros.

CREATE DATABASE proyecto;

USE proyecto

CREATE TABLE IF NOT EXISTS `carrera` (`clave_carrera` int(11) NOT NULL, `nom_carrera` varchar(20) NOT NULL, `num_depto` int(11) NOT NULL, PRIMARY KEY (`clave_carrera`), KEY `num_depto` (`num_depto`) ) ENGINE=InnoDB DEFAULT CHARSET=latin1;

CREATE TABLE IF NOT EXISTS `departamento` ( `num_departamento` int(11) NOT NULL,`nombre_dept` varchar(20) NOT NULL, `jefe_num_tarjet` int(11) NOT NULL, PRIMARY KEY (`num_departamento`), KEY `jefe_num_tarjet` (`jefe_num_tarjet`) ) ENGINE=InnoDB DEFAULT CHARSET=latin1;

CREATE TABLE IF NOT EXISTS `maestros` (`num_tarjeta` int(11) NOT NULL DEFAULT ’0′,`nombre` varchar(50) DEFAULT NULL, PRIMARY KEY (`num_tarjeta`)) ENGINE=InnoDB DEFAULT CHARSET=latin1;

La estructura de la tabla bitácora sería la siguiente:

CREATE TABLE IF NOT EXISTS `bitacora` (`id` int(11) NOT NULL AUTO_INCREMENT, `operacion` varchar(10) DEFAULT NULL, `usuario` varchar(40) DEFAULT NULL, `host` varchar(30) NOT NULL, `modificado` datetime DEFAULT NULL, `tabla` varchar(40) NOT NULL, PRIMARY KEY (`id`) ) ENGINE=InnoDB DEFAULT CHARSET=latin1 AUTO_INCREMENT=1 ;

La bitácora debe registrar todos los movimientos (insertar, eliminar y modificar) que se realicen en las tablas de la base de datos. Para lograr lo anterior es necesario crear un trigger para que se ejecute después de la operación de insertar, otro para después de eliminar y el último para después de modificar para cada una de las 3 tablas de la base de datos. Los nueve triggers necesarios para que funcione la bitácora son los siguientes:

DROP TRIGGER IF EXISTS `bit_carr_ins`;

DELIMITER //

CREATE TRIGGER `bitacora` AFTER INSERT ON `carrera`

FOR EACH ROW INSERT INTO bitacora(host, usuario, operacion, modificado, tabla) VALUES (SUBSTRING(USER(), (INSTR(USER(),’@')+1)), SUBSTRING(USER(),1,(instr(user(),’@')-1)), “INSERTAR”, NOW(), “CARRERA”)

//

DROP TRIGGER IF EXISTS `bit_carr_upd`;

CREATE TRIGGER `bit_carr_upd` AFTER UPDATE ON `carrera`

FOR EACH ROW INSERT INTO bitacora(host, usuario, operacion, modificado, tabla) VALUES (SUBSTRING(USER(), (INSTR(USER(),’@')+1)), SUBSTRING(USER(),1,(instr(user(),’@')-1)), “ACTUALIZAR”, NOW(), “CARRERA”)

//

DROP TRIGGER IF EXISTS `bit_carr_del`;

CREATE TRIGGER `bit_carr_del` AFTER DELETE ON `carrera`

FOR EACH ROW INSERT INTO bitacora(host, usuario, operacion, modificado, tabla) VALUES (SUBSTRING(USER(), (INSTR(USER(),’@')+1)), SUBSTRING(USER(),1,(instr(user(),’@')-1)), “ELIMINAR”, NOW(), “CARRERA”)

//

DROP TRIGGER IF EXISTS `bit_depto_ins`;

CREATE TRIGGER `bit_depto_ins` AFTER INSERT ON `departamento`

FOR EACH ROW INSERT INTO bitacora(host, usuario, operacion, modificado, tabla) VALUES (SUBSTRING(USER(), (INSTR(USER(),’@')+1)), SUBSTRING(USER(),1,(instr(user(),’@')-1)), “INSERTAR”, NOW(), “DEPARTAMENTO”)

//

DROP TRIGGER IF EXISTS `bit_depto_upd`;

CREATE TRIGGER `bit_depto_upd` AFTER UPDATE ON `departamento`

FOR EACH ROW INSERT INTO bitacora(host, usuario, operacion, modificado, tabla) VALUES (SUBSTRING(USER(), (INSTR(USER(),’@')+1)), SUBSTRING(USER(),1,(instr(user(),’@')-1)), “ACTUALIZAR”, NOW(), “DEPARTAMENTO”)

//

DROP TRIGGER IF EXISTS `bit_depto_del`;

CREATE TRIGGER `bit_depto_del` AFTER DELETE ON `departamento`

FOR EACH ROW INSERT INTO bitacora(host, usuario, operacion, modificado, tabla) VALUES (SUBSTRING(USER(), (INSTR(USER(),’@')+1)), SUBSTRING(USER(),1,(instr(user(),’@')-1)), “ELIMINAR”, NOW(), “DEPARTAMENTO”)

//

DROP TRIGGER IF EXISTS `bit_mae_ins`;

CREATE TRIGGER `bit_mae_ins` AFTER INSERT ON `maestros`

FOR EACH ROW INSERT INTO bitacora(host, usuario, operacion, modificado, tabla) VALUES (SUBSTRING(USER(), (INSTR(USER(),’@')+1)), SUBSTRING(USER(),1,(instr(user(),’@')-1)),“INSERTAR”, NOW(), “MAESTROS”)

//

DROP TRIGGER IF EXISTS `bit_mae_upd`;

CREATE TRIGGER `bit_mae_upd` AFTER UPDATE ON `maestros`

FOR EACH ROW INSERT INTO bitacora(host, usuario, operacion, modificado, tabla) VALUES (SUBSTRING(USER(), (INSTR(USER(),’@')+1)), SUBSTRING(USER(),1,(instr(user(),’@')-1)), “ACTUALIZAR”, NOW(), “MAESTROS”)

//

DROP TRIGGER IF EXISTS `bit_mae_del`;

CREATE TRIGGER `bit_mae_del` AFTER DELETE ON `maestros`

FOR EACH ROW INSERT INTO bitacora(host, usuario, operacion, modificado, tabla) VALUES (SUBSTRING(USER(), (INSTR(USER(),’@')+1)), SUBSTRING(USER(),1,(instr(user(),’@')-1)), “ELIMINAR”, NOW(), “MAESTROS”)

sistemas de archivos

¿Qué son los sistemas de archivos?

Un sistema de archivos son los métodos y estructuras de datos que un sistema operativo utiliza para seguir la pista de los archivos de un disco o partición; es decir, es la manera en la que se organizan los archivos en el disco. El término también es utilizado para referirse a una partición o disco que se está utilizando para almacenamiento, o el tipo del sistema de archivos que utiliza. Así uno puede decir “tengo dos sistemas de archivo” refiriéndose a que tiene dos particiones en las que almacenar archivos, o que uno utiliza el sistema de “archivos extendido”, refiriéndose al tipo del sistema de archivos.

La diferencia entre un disco o partición y el sistema de archivos que contiene es importante. Unos pocos programas (incluyendo, razonablemente, aquellos que crean sistemas de archivos) trabajan directamente en los sectores crudos del disco o partición; si hay un archivo de sistema existente allí será destruido o corrompido severamente. La mayoría de programas trabajan sobre un sistema de archivos, y por lo tanto no utilizarán una partición que no contenga uno (o que contenga uno del tipo equivocado).

Sistemas de archivos soportados por Linux

Linux soporta una gran cantidad de tipos diferentes de sistemas de archivos. Para nuestros propósitos los más importantes son:

minix

El más antiguo y supuestamente el más fiable, pero muy limitado en características (algunas marcas de tiempo se pierden, 30 caracteres de longitud máxima para los nombres de los archivos) y restringido en capacidad (como mucho 64 MB de tamaño por sistema de archivos).

xia

Una versión modificada del sistema de archivos minix que eleva los límites de nombres de archivos y tamaño del sistema de archivos, pero por otro lado no introduce características nuevas. No es muy popular, pero se ha verificado que funciona muy bien.

ext3

El sistema de archivos ext3 posee todas las propiedades del sistema de archivos ext2. La diferencia es que se ha añadido una bitácora (journaling). Esto mejora el rendimiento y el tiempo de recuperación en el caso de una caída del sistema. Se ha vuelto más popular que el ext2.

ext2

El más sistema de archivos nativo Linux que posee la mayor cantidad de características. Está diseñado para ser compatible con diseños futuros, así que las nuevas versiones del código del sistema de archivos no necesitará rehacer los sistemas de archivos existentes.

ext

Una versión antigua de ext2 que no es compatible en el futuro. Casi nunca se utiliza en instalaciones nuevas, y la mayoría de la gente que lo utilizaba han migrado sus sistemas de archivos al tipo ext2.

reiserfs

Un sistema de archivos más robusto. Se utiliza una bitácora que provoca que la pérdida de datos sea menos frecuente. La bitácora es un mecanismo que lleva un registro por cada transacción que se va a realizar, o que ha sido realizada. Esto permite al sistema de archivos reconstruirse por sí sólo fácilmente tras un daño ocasionado, por ejemplo, por cierres del sistema inadecuados.

Adicionalmente, existe soporte para sistemas de archivos adicionales ajenos, para facilitar el intercambio de archivos con otros sistemas operativos. Estos sistemas de archivos ajenos funcionan exactamente como los propios, excepto que pueden carecer de características usuales UNIX , o tienen curiosas limitaciones, u otros inconvenientes.

msdos

Compatibilidad con el sistema de archivos FAT de MS-DOS (y OS/2 y Windows NT).

umsdos

Extiende el dispositivo de sistema de archivos msdos en Linux para obtener nombres de archivo largos, propietarios, permisos, enlaces, y archivos de dispositivo. Esto permite que un sistema de archivos msdos normal pueda utilizarse como si fuera de Linux, eliminando por tanto la necesidad de una partición independiente para Linux.

vfat

Esta es una extensión del sistema de archivos FAT conocida como FAT32. Soporta tamaños de discos mayores que FAT. La mayoría de discos con MS Windows son vfat.

iso9660

El sistema de archivos estándar del CD-ROM; la extensión popular Rock Ridge del estándar del CD-ROM que permite nombres de archivo más largos se soporta de forma automática.

nfs

Un sistema de archivos de red que permite compartir un sistema de archivos entre varios ordenadores para permitir fácil acceso a los archivos de todos ellos.

smbfs

Un sistema de archivos que permite compartir un sistema de archivos con un ordenador MS Windows. Es compatible con los protocolos para compartir archivos de Windows.

hpfs

El sistema de archivos de OS/2.

sysv

EL sistema de archivos de Xenix, Coherent y SystemV/386..

Crear un sistema de archivos

Un sistema de archivos se crea, esto es, se inicia, con el comando mkfs. Existen en realidad programas separados para cada tipo de sistemas de archivos. mkfs es únicamente una careta que ejecuta el programa apropiado dependiendo del tipo de sistemas de archivos deseado. El tipo se selecciona con la opción -t fstype.

Los programas a los que -t fstype llama tienen líneas de comando ligeramente diferentes. Las opciones más comunes e importantes se resumen más abajo; vea las páginas de manual para más información.

-t fstype

Selecciona el tipo de sistema de archivos.

-c

Busca bloques defectuosos e inicia la lista de bloques defectuosos en consonancia.

-l filename

Lee la lista inicial de bloques defectuosos del archivo dado.

Instancias y Particiones De Disco

Las particionesCada disco duro constituye una unidad física. Sin embargo, los sistemas operativos no trabajan con unidades físicas directamente sino con unidades lógicas. Dentro de una misma unidad física de disco duro puede haber varias unidades lógicas. Cada una de estas unidades lógicas constituye una partición del disco duro. Esto quiere decir que podemos dividir un disco duro en, por ejemplo, dos particiones (dos unidades lógicas dentro de una misma unidad física) y trabajar de la misma manera que si tuviésemos dos discos duros (una unidad lógica para cada unidad física).

Particiones y directorios

Ambas estructuras permiten organizar datos dentro de un disco duro. Sin embargo, presentan importantes diferencias: 1ª) Las particiones son divisiones de tamaño fijo del disco duro; los directorios son divisiones de tamaño variable de la partición; 2ª) Las particiones ocupan un grupo de cilindros contiguos del disco duro (mayor seguridad); los directorios suelen tener su información desperdigada por toda la partición (por ello es necesaria la defragmentación periódica); 3ª) Cada partición del disco duro puede tener un sistema de archivos (FAT, FAT32, NTFS, etc.) distinto; todos los directorios de una partición tienen el mismo sistema de archivos. Como mínimo, es necesario crear una partición para cada disco duro. Esta partición puede contener la totalidad del espacio del disco duro o sólo una parte. Las razones que nos pueden llevar a crear más de una partición por disco se suelen reducir a tres:

1) Razones organizativas - Considérese el caso de una computadora que es compartida por dos usuarios y, con objeto de lograr una mejor organización y seguridad de sus datos, deciden utilizar particiones separadas.

2) Instalación de más de un sistema operativo - Debido a que cada sistema operativo requiere (como norma general) una partición propia para trabajar, si queremos instalar dos sistemas operativos a la vez en el mismo disco duro (por ejemplo, Windows 98 y Linux), será necesario particionar el disco.

3) Razones de eficiencia - Por ejemplo, suele ser preferible tener varias particiones FAT pequeñas antes que una gran partición FAT. Esto es debido a que cuanto mayor es el tamaño de una partición, mayor es el tamaño del grupo (clúster) y, por consiguiente, se desaprovecha más espacio de la partición. Más adelante, explicaremos esto con mayor detalle.

Las particiones pueden ser de dos tipos: primarias o lógicas. Las particiones lógicas se definen dentro de una partición primaria especial denominada partición extendida. En un disco duro sólo pueden existir 4 particiones primarias (incluida la partición extendida, si existe). Las particiones existentes deben inscribirse en una tabla de particiones de 4 entradas situada en el primer sector de todo disco duro. De estas 4 entradas de la tabla puede que no esté utilizada ninguna (disco duro sin particionar, tal y como viene de fábrica) o que estén utilizadas una, dos, tres o las cuatro entradas. En cualquiera de estos últimos casos (incluso cuando sólo hay una partición), es necesario que en la tabla de particiones figure una de ellas como partición activa. La partición activa es aquella a la que el programa de inicialización (Master Boot) cede el control al arrancar. El sistema operativo de la partición activa será el que se cargue al arrancar desde el disco duro. Más adelante veremos distintas formas de elegir el sistema operativo que queremos arrancar, en caso de tener varios instalados, sin variar la partición activa en cada momento.

De todo lo anterior se pueden deducir varias conclusiones: Para que un disco duro sea utilizable debe tener al menos una partición primaria. Además para que un disco duro sea arrancable debe tener activada una de las particiones y un sistema operativo instalado en ella. Más adelante, se explicará en detalle la secuencia de arranque de una computadora. Esto quiere decir que el proceso de instalación de un sistema operativo en una computadora consta de la creación de su partición correspondiente, instalación del sistema operativo (formateo de la partición y copia de archivos) y activación de la misma. De todas maneras, es usual que este proceso esté guiado por la propia instalación del SO (sistema operativo). Un disco duro no arrancará si no se ha definido una partición activa o si, habiéndose definido, la partición no es arrancable (no contiene un sistema operativo).

Hemos visto antes que no es posible crear más de cuatro particiones primarias. Este límite se logra subsanar mediante la creación de una partición extendida (como máximo una). Esta partición ocupa, al igual que el resto de las particiones primarias, una de las cuatro entradas posibles de la tabla de particiones. Dentro de una partición extendida se pueden definir particiones lógicas sin límite. El espacio de la partición extendida puede estar ocupado en su totalidad por particiones lógicas o bien, tener espacio libre sin particionar.

Veamos el mecanismo que se utiliza para crear la lista de particiones lógicas. En la tabla de particiones del Master Boot Record debe existir una entrada con una partición extendida (la cual no tiene sentido activar). Esta entrada apunta a una nueva tabla de particiones similar a la ya estudiada, de la que sólo se utilizan sus dos primeras entradas. La primera entrada corresponde a la primera partición lógica; la segunda, apuntará a una nueva tabla de particiones. Esta nueva tabla contendrá en su primera entrada la segunda partición lógica y en su segunda, una nueva referencia a otra tabla. De esta manera, se va creando una cadena de tablas de particiones hasta llegar a la última, identificada por tener su segunda entrada en blanco.

Particiones primarias y particiones lógicas

Ambos tipos de particiones generan las correspondientes unidades lógicas de la computadora. Sin embargo, hay una diferencia importante: sólo las particiones primarias se pueden activar. Además, algunos sistemas operativos no pueden acceder a particiones primarias distintas a la suya.

Lo anterior nos da una idea de qué tipo de partición utilizar para cada necesidad. Los sistemas operativos (SO) deben instalarse en particiones primarias, ya que de otra manera no podrían arrancar. El resto de particiones que no contengan un sistema operativo, es más conveniente crearlas como particiones lógicas (por ejemplo, un sector del disco duro que ha de servir como depósito de instaladores, imágenes, mp3, documentos de textos, e-books. etc.). Por dos razones: primera, no se malgastan entradas de la tabla de particiones del disco duro y, segunda, se evitan problemas para acceder a estos datos desde los sistemas operativos instalados. Las particiones lógicas son los lugares ideales para contener las unidades que deben ser visibles desde todos los sistemas operativos. Algunos sistemas operativos presumen de poder ser instalados en particiones lógicas (Windows NT), sin embargo, esto no es del todo cierto: necesitan instalar un pequeño programa en una partición primaria que sea capaz de cederles el control.

Estructura lógica de las particiones

Dependiendo del sistema de archivos utilizado en cada partición, su estructura lógica será distinta. En los casos de MS-DOS y Windows 95, está formada por sector de arranque, FAT, copia de la FAT, directorio raíz y área de datos. De todas formas, el sector de arranque es un elemento común a todos los tipos de particiones.

Todas las particiones tienen un sector de arranque (el primero de la partición) con información relativa a la partición. Si la partición tiene instalado un sistema operativo, este sector se encargará de arrancarlo. Si no hubiese ningún sistema operativo (como es el caso de una partición para datos) y se intentara arrancar, mostraría un mensaje de error.

Instancias

La instancia es la unión de los procesos y de las estructuras de memoria, los cuales se hallan en ejecución para el acceso de los usuarios a los datos a través de diferentes aplicaciones como por ejemplo administración, desarrollo y otras aplicaciones de usuario final.

Es el conjunto de procesos del servidor que permiten el acceso a la base de datos. Es un conjunto de estructuras de datos y procesos en memoria. Está formado por:

SGA. Area global de sistema. Se trata de la zona de memoria común para todos los procesos de servidor, contien las siguientes estructuras de datos fundamentales:

Buffer de caché de base de datos. Almacena bloques de datos leídos de la base de datos a fin de que las próximas consultas no necesiten acudir a disco y se las pueda servir de estos datos en la caché.

Buffer redo log. Estructura que almacena los datos anteriores y posteriores a cada instrucción y así facilitar tanto su anulación, como su realización en caso de problemas.

Large pool. Área de la memoria que proporciona espacio para los datos necesarios para realizar operaciones de backup y restauración, así como los datos de sesión y otros que permitan aliviar el trabajo de la instancia.

Shared pool. Consta de la caché del diccionario de datos y de la caché de instrucciones SQL, PL/SQL. De esa forma se acelera la ejecución de consultas e instrucciones que utilicen los mismos metadatos o bien que se traten de instrucciones parecidas a otras anteriormente ejecutadas.

Java Pool. Sólo se usa si hemos instalado Java para agilizar el proceso de las instrucciones en ese lenguaje.