admon de base de datos

jueves, 17 de octubre de 2013

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,
);

martes, 15 de octubre de 2013

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`

DROP TRIGGER IF EXISTS `bit_carr_del`;

CREATE TRIGGER `bit_carr_del` AFTER DELETE ON `carrera`

DROP TRIGGER IF EXISTS `bit_depto_ins`;

CREATE TRIGGER `bit_depto_ins` AFTER INSERT ON `departamento`

DROP TRIGGER IF EXISTS `bit_depto_upd`;

CREATE TRIGGER `bit_depto_upd` AFTER UPDATE ON `departamento`

DROP TRIGGER IF EXISTS `bit_depto_del`;

CREATE TRIGGER `bit_depto_del` AFTER DELETE ON `departamento`

DROP TRIGGER IF EXISTS `bit_mae_ins`;

CREATE TRIGGER `bit_mae_ins` AFTER INSERT ON `maestros`

DROP TRIGGER IF EXISTS `bit_mae_upd`;

CREATE TRIGGER `bit_mae_upd` AFTER UPDATE ON `maestros`

DROP TRIGGER IF EXISTS `bit_mae_del`;

CREATE TRIGGER `bit_mae_del` AFTER DELETE ON `maestros`

lunes, 14 de octubre de 2013

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.

miércoles, 9 de octubre de 2013

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.

Instancias de un SGBD y su aplicación

Tipos de instancias

Online Transaction Processing (OLTP): compra/venta, telemarketing

Segmentos cortos de rollback

Shared Pool muy largo

Redo log suficiente

Indices en discos separados

Segmentos temporales pequeños

DecisionSupportSystems (DSS): datawarehouse

Segmentos largos de rollback

Shared Pool relativamente corto

Redo log suficiente

Indices apropiados

Segmentos largos de temporal

ParallelQuery en la medida de lo posible (si está disponible)

Los usuarios que deseen conectarse a una base de datos, se conectan a lo que se conoce como la instancia de la base de datos (del inglés instance).

Es el modo más sencillo de trabajo, el usuario dispone de un software en su máquina local, por lo que se encuentra en el lado del cliente, capaz de conectar con el SGBD. En ese momento se lanza un proceso de usuario. Ese proceso deberá comunicarse (a través de las redes apropiadas) con el proceso de servidor, un programa lanzado en el lado del servidor que está permanentemente en ejecución.

El proceso de servidor comunica a su vez con la instancia de la base de datos, otro proceso en ejecución a través del cual se accede a la base de datos.

Configurar instancias

Cada instancia de Motor de base de datos debe configurarse satisfacer los requisitos de rendimiento y disponibilidad definidos para las bases de datos hospedadas por la instancia.El Motor de base de datos incluye opciones de configuración que controlan comportamientos como el uso de recursos y la disponibilidad de características como la los comportamientos de control como el uso de los recursos y la disponibilidad de características como auditoría o recursividad de desencadenador.

Aplicación

Puede ejecutar múltiples instancias de Motor de base de datos en un equipo.Una instancia puede ser la instancia predeterminada.La instancia predeterminada no tiene nombre.Si una solicitud de conexión especifica solo el nombre del equipo, se establece la conexión a la instancia predeterminada.Una instancia con nombre es una instancia en la que se especifica un nombre de instancia al instalar la instancia.Una solicitud de conexión debe especificar el nombre del equipo y el nombre de instancia para conectar a la instancia.No hay ningún requisito para instalar una instancia predeterminada; todas las instancias que se ejecutan en un equipo pueden ser instancias con nombre.

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 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.

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

Procesos en segundo plano. Programas en ejecución que realizan las tareas fundamentales sonre la base de datos, entre ellos:

DBWR. Escribe los datos del buffer de cache de la base de datos de la SGA a la base de datos en disco (a los archivos de datos). Eso no ocurre en todo momento, sino cuando se produce un evento de tipo checkpoint.

Un checkpoint ocurre cuando se ha consumido un tiempo determinado por el DBA, que se establece para que cada cierto tiempo los datos pasen a grabarse en ficheros de datos y así asegurarles en caso de problemas. El hecho de que esto se haga solo cada cierto tiempo (el tiempo establecido para el checkpoint) se debe a que, de otro modo, el funcionamiento sería muy lento si se accediera más a menudo al disco.

LGWR. Es el proceso que genera escrituras secuenciales en los redo logs (archivos log de rehacer) que son los archivos que guardan la información necesaria para poder recuperar un estado anterior en los datos.

Las instrucciones DML están limitadas por la velocidad de este proceso al guardar los datos. LGWR escribe desde el buffer del caché redo en el SGA hacia los archivos redo en disco.

CKPT. Proceso encargado de comunicar la llegada de un checkpoint, punto de control que ocurre cíclicamente (y que se puede modificar poe el DBA) tras el cual se deben de escribir los datos de memoria a los archivos de datos.

SMON. System Monitor.Proceso encargado de monitorizar el sistema para que funcione correctamente tras un error grave. Además se encarga de la optimización del sistema mejorando el espacio en disco y elimando definitivamente (mediante rollbacks) datos irrecuperables.

PMON. Process Monitor.Se encarga de la comunicación con la PGA y especialmente con el proceso servidor para manejar la conexión con el cliente, eliminado transacciones de usuarios erróneas (por desconexión por ejemplo) y liberando la memoria que se reservó para los usuarios.

ARCn. Proceso de archivado de los archivos Redo. Sirve para que esos datos siempre estén disponibles. Sólo funciona en modo ARCHIVELOG de la base de datos, se explica más adelante

Disco (Particiones)
Los sistemas Unix siempre han tenido la posibilidad de montar un subsistema de almacenamiento de varias particiones. Estas particiones pueden estar repartidas en varios dispositivos físicos, o pueden ser varias particiones en un mismo dispositivo físico. Cada disco debe tener al menos una partición, pero a menudo hay más. Nos limitaremos aquí a el particionado tal y como se hace en los discos duros en un entorno de un PC.
Al principio, cuando los discos tenían muy poco espacio, se tenía la idea de que cuatro particiones serían suficientes para todo el uso posible que se le fuera a dar al disco duro (con el tiempo se ha evolucionado y aquella idea ha quedado obsoleta, puediendo necesitar más de esas 4 particiones posibles). Los datos sobre el particionado están escrito en la tabla de particiones. Se encuentra en un lugar especial en el disco y el BIOS accede a ella para consultarla.
Cuando se hizo muy evidente que cuatro particiones no iban a ser suficientes, se encontró e implementó una solución compatible con las versiones anteriores: hacer una de las cuatro particiones, una partición especial, que puede contener varias particiones. Las BIOS más reciente (en la actualidad todas las BIOS) conocen este nuevo tipo de particiones y pueden utilizarlas. Así pues, tenemos tres tipos de particiones:

Particiones primarias: estas son las antiguas 4 particiones primigenias, puede haber hasta 4 (numeradadas con los números 1, 2, 3, 4).

Partición extendida: (de hecho también es una partición primaria), sólo puede haber una, tiene normalmente el número más alto después de la creada como partición primaria (3 ó 4) y debe contener todo el espacio restante del disco (de lo contrario el espacio queda desperdiciado).

Particiones secundarias: que se crean dentro de la partición extendida, su numeración es siempre 5 o superior (el máximo es discutible, pero suele ser suficiente para la mayoría de la gente).

Algunas personas están desconcertadas por la existencia de la partición extendida, que no parece ser de ninguna utilidad y ocupa una gran cantidad de espacio en disco y que el espacio parece que también pertenecen a otras particiones útil. La partición extendida actúa como un contenedor para las particiones secundarias , y el espacio que se muestra corresponde tanto a la partición extendida como a las particiones secundarias que contiene.

sistema de archivos
Ahora ya tenemos una o más particiones y queremos usarlas. Algunos programas, que hacen un uso intensivo de disco I/O, pueden utilizar particiones raw, pero sobre todo queremos poner los datos organizados en los directorios/archivos, o utilizarlo como intercambio swap. Para utilizarlo como sistema de ficheros (o swap) debemos crear un sistema de archivos en la partición. Muchas personas llaman a este proceso formateo, pero en Unix/Linux lo que se hace es crear o realizar un sistema de archivos y la herramienta para hacerlo desde la consola es mkfs. No entraré en detalles aquí, pero lo que sucede en un sistema de archivos vacío (inodos, etc) depende del tipo de sistema de archivos elegido. Un tipo de sistemas de archivo ReiserFS es diferente de un sistema de archivos ext3 o ext4. Se debe elegir, pero si no sabes mucho del tema, escoger los valores por defecto no es una mala opción.

PARTICIONES Y SISTEMAS DE ARCHIVOS

1.- Explica las diferencias que hay entre una partición primaria, una partición lógica y una extendida.
Partición Primaria: Partición que puede contener los archivos necesarios para arrancar el sistema y que no puede ser subdividida.
Partición Lógica: Partición que existe dentro de una partición extendida. PARTICIONES PRIMARIAS:

Partición Extendida: Partición que no puede contener los archivos necesarios para arrancar el sistema y que puede ser a su vez subdividida en unidades lógicas..
Estas son las particiones

2.- Explica las opciones del fdisk de Microsoft
3.- Indica cuál es la nomenclatura que utiliza Windows y Linux para nombrar las

unidades de disco.
NOMENCLATURA WINDOWS

Las particiones de un disco duro son "trozos" del mismo cuyo principal fin debiera ser la de albergar distintos sistemas de ficheros (distintos sistemas operativos) incompatibles entre sí, que no pueden convivir en la misma partición.
Particionar un disco duro consiste en dividir al mismo en distintos "trozos". Existen dos tipos de particiones, particiones primarias y particiones extendidas. Las particiones primarias sirven para albergar sistemas operativos y datos de programa, todo disco duro tiene al menos una partición primaria para contener datos y la mayor parte de los usuarios disponen de una única partición con el tamaño total del disco duro. El número máximo de particiones primarias es 4. Fué este número tan pequeño el que originó la aparición de las particiones extendidas, las cuales se utilizan para alargar el número máximo de particiones hasta el infinito (en la práctica no se aconseja un número de particiones superior a 12), puesto que una partición extendida puede contener tantas particiones primarias (denominadas en esta caso unidades lógicas) como se quiera.
A veces aún poseyendo un único sistema operativo, si el disco duro tiene una gran capacidad, entonces, bien por antiguas exigencias del propio sistema operativo incapaz de crear particiones primarias tan grandes tales como la capacidad total de un disco duro grande, bien por razones de optimización(se obtiene mayor rendimiento de un disco duro particionado en varios trozos, tanto por velocidad de acceso como por un mejor aprovechamiento del espacio disponible), a veces se recurre a la creación de una partición extendida. A partir de una partición extendida se crean unidades lógicas para poder acceder a ese espacio. En el caso más simple se crea una unidad lógica con la capacidad total de la partición extendida., tal y como expresa el siguiente gráfico: