CAPITULO II - Repositorio Digital UTN

TECNICAS DE PROGRAMACION VISUAL PARA APLICAICIONES DOS CAPAS EN LA PLATAFORMA LINUX
CAPITULO II
BASES DE DATOS
Introducción
Objetivos de los sistemas de gestión de base de datos (SGBD)
Concepción de una base de datos
Problemas adquiridos por una mala concepción de una base de datos
Estructura básica del lenguaje de programación SQL
Motores de Bases de Datos
PostgreSQL
Características
MySQL
Características
Análisis de las Bases de Datos (Ventajas, Desventajas)
RENAN NAZATE ORTIZ
35
TECNICAS DE PROGRAMACION VISUAL PARA APLICAICIONES DOS CAPAS EN LA PLATAFORMA LINUX
Introducción
Una base de datos está generalmente definida como un conjunto integrado
de datos que modelizan un universo dado. Este universo está compuesto por
objetos inter-relacionados, los objetos de un mismo tipo constituyen una
entidad y el lazo habido entre entidades se le denomina asociación.
El proceso de descripción de asociaciones y entidades se llama
modelización y se hace con la ayuda de un modelo de datos, existen
actualmente cuatro modelos de datos diferentes:
 Modelo jerárquico. Éstas son bases de datos que como su nombre
indica, almacenan su información en una estructura jerárquica. En este
modelo los datos se organizan en una forma similar a un árbol (visto al
revés), en donde un nodo padre de información puede tener varios hijos.
El nodo que no tiene padre es llamado raíz, y a los nodos que no tienen
hijos se los conoce como hojas.
Una de las principales limitaciones de este modelo es su incapacidad de
representar eficientemente la redundancia de datos.
Fig. 2.1 Estructura del modelo jerárquico
 Modelo en red. Éste es un modelo ligeramente distinto del jerárquico;
su diferencia fundamental es la modificación del concepto de nodo: se
RENAN NAZATE ORTIZ
36
TECNICAS DE PROGRAMACION VISUAL PARA APLICAICIONES DOS CAPAS EN LA PLATAFORMA LINUX
permite que un mismo nodo tenga varios padres (posibilidad no
permitida en el modelo jerárquico).
Fue una gran mejora con respecto al modelo jerárquico, ya que ofrecía
una solución eficiente al problema de redundancia de datos; pero, aun
así, la dificultad que significa administrar la información en una base de
datos de red ha significado que sea un modelo utilizado en su mayoría
por programadores más que por usuarios finales.
Fig. 2.2 Estructura del modelo de red
 Modelo objeto. Este modelo, bastante reciente, y propio de los modelos
informáticos orientados a objetos, trata de almacenar en la base de
datos los objetos completos (estado y comportamiento).
Una base de datos orientada a objetos es una base de datos que
incorpora todos los conceptos importantes del paradigma de objetos:
Encapsulación - Propiedad que permite ocultar la información al resto
de los objetos, impidiendo así accesos incorrectos o conflictos.
Herencia - Propiedad a través de la cual los objetos heredan
comportamiento dentro de una jerarquía de clases.
Polimorfismo - Propiedad de una operación mediante la cual puede ser
aplicada a distintos tipos de objetos.
RENAN NAZATE ORTIZ
37
TECNICAS DE PROGRAMACION VISUAL PARA APLICAICIONES DOS CAPAS EN LA PLATAFORMA LINUX
En bases de datos orientadas a objetos, los usuarios pueden definir
operaciones sobre los datos como parte de la definición de la base de
datos. Una operación (llamada función) se especifica en dos partes. La
interfaz (o signatura) de una operación incluye el nombre de la operación
y los tipos de datos de sus argumentos (o parámetros). La
implementación
(o
método)
de
la
operación
se
especifica
separadamente y puede modificarse sin afectar la interfaz. Los
programas de aplicación de los usuarios pueden operar sobre los datos
invocando a dichas operaciones a través de sus nombres y argumentos,
sea cual sea la forma en la que se han implementado. Esto podría
denominarse independencia entre programas y operaciones.
 Modelo relacional. Éste es el modelo más utilizado en la actualidad
para modelar problemas reales y administrar datos dinámicamente. Su
idea fundamental es el uso de "relaciones". Estas relaciones podrían
considerarse en forma lógica como conjuntos de datos llamados
"tuplas".
Pese a que ésta es la teoría de las bases de datos relacionales, la
mayoría de las veces se conceptualiza de una manera más fácil de
imaginar. Esto es pensando en cada relación como si fuese una tabla
que está compuesta por registros (las filas de una tabla), que
representarían las tuplas, y campos (las columnas de una tabla).
En este modelo, el lugar y la forma en que se almacenen los datos no
tienen relevancia (a diferencia de otros modelos como el jerárquico y el
de red). Esto tiene la considerable ventaja de que es más fácil de
entender y de utilizar para un usuario esporádico de la base de datos. La
información puede ser recuperada o almacenada mediante "consultas"
que ofrecen una amplia flexibilidad y poder para administrar la
información.
RENAN NAZATE ORTIZ
38
TECNICAS DE PROGRAMACION VISUAL PARA APLICAICIONES DOS CAPAS EN LA PLATAFORMA LINUX
Características
MODELO RELACIONAL
valores atómicos
Columnas con nombre
Distinción de columnas individuales por dominios y por nombres
Normalmente varía con el tiempo
Durante su diseño, una base de datos relacional pasa por un proceso al
que se le conoce como normalización de una base de datos.
Objetivos de los sistemas de gestión de base de datos (SGBD):
Las funciones de los SGBD son:
a. Permitir la definición de todos los datos (L.D.D)
b. Permitir manipular datos (L.M.D)
c. Establecer controles para la seguridad de estos datos (L.M.C)
d. Permitir los accesos concurrentes.
a. Definición de datos: La misión es describir y definir todos los
esquemas que participen en la base de datos. Esto consiste en la
descripción de los objetos, la descripción de todas las estructuras que
formen nuestra base de datos.
Definición de vista: Es una visión parcial de la tabla. “cuando en una
tabla alguna parte de esta no quiero que tenga derecho a manipularla
nadie”
b. Manipulación de datos:
Recoge todas las operaciones de
intercambio de datos entre las tablas, estas operaciones pueden ser
RENAN NAZATE ORTIZ
39
TECNICAS DE PROGRAMACION VISUAL PARA APLICAICIONES DOS CAPAS EN LA PLATAFORMA LINUX
de consulta o de puesta al día (inserción, modificación, supresión)
estas operaciones se realizan con la ayuda del denominado L.M.D.
-consultas
Operaciones
- insertar datos
- puesta al día
- modificar datos
- suprimir datos
c. Seguridad de los datos: Consiste en garantizar que sólo los
usuarios autorizados puedan efectuar operaciones correctas sobre la
Base de Datos para ello se dispone de 2 tipos.

Control sobre la base de datos

Control sobre las tablas
d. Gestión de los accesos concurrentes: El principal objetivo
de la implantación de una base de datos es poner a disposición de un
gran número de usuarios en conjunto integrado de datos, estos datos
podrán ser manipulados por los diferentes usuarios y es ahora cuando
se debe garantizar la coherencia de los datos después de las diversas
manipulaciones. Esto se garantiza con la ayuda del concepto de
transacción “se define como transacción a una unidad lógica de
tratamiento que aplicada a un estado coherente de una base de datos
restituye un nuevo estado coherente de la base de datos pero con
estos modificados, únicamente puede ser modificada completamente
anulado”.
Concepción de una base de datos:
El ciclo de vida de una base de datos puede descomponerse en
3
etapas:
 Concepción: La fase de concepción consiste en reproducir en el
mundo real con ayuda de uno de los modelos de datos conocidos
RENAN NAZATE ORTIZ
40
TECNICAS DE PROGRAMACION VISUAL PARA APLICAICIONES DOS CAPAS EN LA PLATAFORMA LINUX
(relacional). El resultado de esta fase es un esquema escrito
según un formalismo cualquiera no interpretable por el SGBD.
 Creación de la Base de Datos vacía: La 2ª fase consiste en
traducir este esquema en órdenes comprensibles para el SGBD.
Como resultado se obtiene la estructura de la base de datos
desprovista de cualquier tipo de información.
 Explotación: Es en esta fase donde los registros serán
manipulados con la ayuda de los lenguajes de programación. Es
ahora cuando los usuarios pueden consultar los datos y ponerlos
a punto durante el resto de la vida de la base de datos.
Problemas adquiridos por una mala concepción de una base de datos:
En las tablas hay que procurar que no haya duplicidad de datos:
 Redundancia de datos: Si un cliente ha realizado más de un pedido
todos los datos de este cliente estarán repetidos tantas veces como
pedidos haya, lo mismo sucede para los artículos esto es opuesto al
principal objetivo de una base de datos que consiste en evitar la
repetición de los mismos.
 Puestas al día múltiple: Para poder asegurar la coherencia de los
datos es necesario efectuar puestas a días múltiples. ”Cuando un
cliente cambia de dirección”
 Incoherencia de los datos: Sí una operación de puesta al día
múltiple no se ha realizado completamente el estado de la base de
datos queda incoherente y puede producir errores importantes.
 Pérdida de datos: La supresión de una línea en la tabla de pedidos
entraña la pérdida de todos los datos relativos a un cliente si no ha
efectuado ningún otro pedido. Esto es cierto también para un artículo
que no ha sido pedido por ningún otro cliente. Estas anormalidades
RENAN NAZATE ORTIZ
41
TECNICAS DE PROGRAMACION VISUAL PARA APLICAICIONES DOS CAPAS EN LA PLATAFORMA LINUX
constituyen lo que se ha convenido en llamar “comportamiento
anormal de las tablas”, para evitar esto existe un proceso llamado
“normalización” que entre otras cosas intenta esclarecer los
conceptos de “dependencia funcional y estado de las tablas”.
 Dependencia funcional: Este concepto se aplica a las columnas y
consiste en hacer corresponder un único valor a aquella columna o
columnas que consideremos más significativas.
 Estado de la tabla: Se dice que una tabla esta en estado de 1ª forma
normal si toda columna de esta tabla no puede tener más que valores
atómicos, un valor es atómico si él no es divisible.
Estructura básica del lenguaje de programación SQL:
 Base de datos: Esta compuesta de un conjunto de tablas del
sistema creadas implícitamente por él y por un conjunto de tablas
y vistas creadas por el usuario.
 Tablas: Representan una entidad o a una asociación entre
entidades. Las tablas están compuestas de columnas o de líneas
o filas llamadas convencionalmente campos y registros. Una
columna representa un atributo de la entidad y para describirla es
necesario especificar un nombre y un tipo de datos, una
particularidad de las columnas es que pueden permitir o no valores
nulos.
 Fila: Es una combinación de los diferentes atributos del objeto
(registro).
 Vistas: Es una tabla virtual definida sobre las tablas bases
descritas por el usuario su objeto es permitir a los usuarios
manipular un subconjunto de datos.
RENAN NAZATE ORTIZ
42
TECNICAS DE PROGRAMACION VISUAL PARA APLICAICIONES DOS CAPAS EN LA PLATAFORMA LINUX
 Usuarios: Uno de los objetivos de un sistema de gestión de base
de datos es el de afianzar la seguridad de los datos, para hacer
esto el lenguaje de programación genera todos los usuarios y sus
permisos de acceso para acceder a una base de datos, cada
usuario debe disponer de su autorización correspondiente y es el
propietario de la base de datos el que debe dar y retirar permisos
de acceso.
Motores de Bases de Datos
Se puede deducir que un motor de Bases de Datos (DBM por sus siglas en
inglés) facilita las funciones de:
almacenar físicamente,
garantizar consistencia,
garantizar integridad,
atomicidad transaccional, y
manejar vistas a la información.
Como algunos ejemplos podemos citar a PostgreSQL, MySQL, Oracle, Sybase
entres otros. [www-10]
Aplicación
Motor
de datos
Base
de
datos
Fig. 2.3 Diagrama que representa el uso de un DBM
PostgreSQL
PostgreSQL es un SGBDR gratuito que soporta base de datos Objeto y SQL,
es además un Sistema de Base de Datos Objeto – Relacional que corre bajo
diversas plataformas hardware y sistemas operativos.
RENAN NAZATE ORTIZ
43
TECNICAS DE PROGRAMACION VISUAL PARA APLICAICIONES DOS CAPAS EN LA PLATAFORMA LINUX
Postgres ofrece una potencia adicional sustancial al incorporar los siguientes
cuatro conceptos adicionales básicos en una vía en la que los usuarios pueden
extender fácilmente el sistema.
 Clases. Es una implantación de un tipo de objetos. Especifica una
estructura de datos y los métodos operativos permisibles que se aplican
a cada uno de sus objetos.
 Herencia. Propiedad a través de la cual los objetos heredan
comportamiento dentro de una jerarquía de clases.
 Tipos. Es un conjunto de objetos que tienen un mismo comportamiento
(comparten una misma funcionalidad) que se puede observar desde
afuera.
 Funciones. Permiten realizar y aumentar la potencia del motor de base
de datos con la utilización de estas funciones.
Otras características que aportan potencia y flexibilidad adicional:
 Restricciones (Constraints). Mediante estas restricciones en la
implementación del código no se podrá acceder a ciertas partes en las
que se declare no accesible.
 Disparadores (triggers). Son triggers que hacen ejecutar una acción
cuando un evento ocurre en la base de datos.
Acciones. Una acción es una función del disparador
Eventos. Son utilizados para modificar una base de datos
(INSERT, UPDATE, DELETE)
 Reglas (rules). Las reglas son las políticas y las que se deben tener en
cuenta en el análisis de una base de datos a realizar.
RENAN NAZATE ORTIZ
44
TECNICAS DE PROGRAMACION VISUAL PARA APLICAICIONES DOS CAPAS EN LA PLATAFORMA LINUX
 Integridad transaccional. La integridad referencial es un sistema de
reglas que utilizan la mayoría de las bases de datos relacionales para
asegurarse que los registros de tablas relacionadas son válidos y que no
se borren o cambien datos relacionados de forma accidental
produciendo errores de integridad.
Características:
 Implementación del estándar SQL92/SQL99.
 Soporta distintos tipos de datos: además del soporte para los tipos base,
también soporta datos de tipo fecha, monetarios, elementos gráficos,
datos sobre redes (MAC, IP...), cadenas de bits, etc. También permite la
creación de tipos propios.
 Incorpora una estructura de datos array.
 Incorpora funciones de diversa índole: manejo de fechas, geométricas,
orientadas a operaciones con redes, etc.
 Permite la declaración de funciones propias, así como la definición de
disparadores.
 Soporta el uso de índices, reglas y vistas.
 Incluye herencia entre tablas (aunque no entre objetos, ya que no
existen), por lo que a este gestor de bases de datos se le incluye entre
los gestores objeto-relaciónales.
 Permite la gestión de diferentes usuarios, como también los permisos
asignados a cada uno de ellos. [www-11, 12]
RENAN NAZATE ORTIZ
45
TECNICAS DE PROGRAMACION VISUAL PARA APLICAICIONES DOS CAPAS EN LA PLATAFORMA LINUX
Como un ejemplo claro de la utilización del código PostgreSQL es el siguiente
ejemplo en la realización de la base de datos para el sistema del Hospital
Comunitario “San José Obrero”.
/*#=====================================================
#Sistema de bases para el hospital "San José Obrero"
#create database sanjose;
#====================================================
#===========================================================
# Table: USUARIO
#===========================================================
#drop table usuario*/
create table usua_previ (
usuario varchar(40) not null,
contras varchar(30) not null,
previle varchar(30) not null,
constraint PK_PREV_US primary key (usuario));
/*#====================================================
#Tabla medicamentos_farmacia necesaria para llenar datos
#acerca de los medicinas utilizados
#======================================================
#drop table farmacia*/
create table farmacia (
cod_medi_insu_farmacia varchar (30) not null,
nombre_comer_insumo_medicamento varchar (60) not null,
nombre_generico_medicamento varchar (60) default null,
precio_unitario decimal not null,
presentacion char (6) not null,
stock_insu_medicamento int not null,
cant_llevada decimal not null,
cant_llevada_unit decimal not null,
fecha_adquisicion date not null,
RENAN NAZATE ORTIZ
46
TECNICAS DE PROGRAMACION VISUAL PARA APLICAICIONES DOS CAPAS EN LA PLATAFORMA LINUX
fecha_caducidad date not null,
constraint
PK_MEDICAMENTOS_FARMACIA
primary
(cod_medi_insu_farmacia));
/*#====================================================
#Tabla procedimiento para llenar datos
#acerca de datos acerca del procedimiento
#======================================================
#drop table procedimiento*/
create table procedimiento (
cod_cirugia varchar (30) not null,
procedimiento_cirugia varchar (60) not null,
num_puntos_ci decimal null,
num_puntos_ay decimal null,
valor_puntos decimal null,
valor_total_ciru decimal not null,
valor_total_ayu decimal not null,
valor_apro decimal null,
constraint PK_PROCEDI primary key (cod_cirugia));
/*#====================================================
#Tabla datos_personal cirugia para llenar datos
#acerca de Medicos, enfermeras, etc.
#======================================================
#drop table datos_personal*/
create table datos_personal (
cc_personal varchar (10) not null,
nombre_personal varchar (60) not null,
telef_personal varchar (9) default null,
direccion varchar (75) default null,
edad int default null,
especialidad varchar (25) default null,
constraint PK_DAT_PERSON primary key (cc_personal));
RENAN NAZATE ORTIZ
47
key
TECNICAS DE PROGRAMACION VISUAL PARA APLICAICIONES DOS CAPAS EN LA PLATAFORMA LINUX
/*#=====================================================
#Tabla examen_laboratorio para llenar datos de examenes
reazados al paciente
#======================================================*/
create table examen_laboratorio (
cod_examen varchar (30) not null,
nombre_examen varchar (60) not null,
presenta varchar (5) not null,
precio_unitario_examen decimal not null,
fecha_examen date null,
constraint PK_DATO_EXAMEN_PERSON primary key (cod_examen));
/*#=====================================================
#Tabla recien_nacido para llenar datos del recien nacido
#======================================================*/
create table recien_nacido (
cod_rn varchar (30) not null,
apell_rn varchar (40) not null,
hora_naci_rn timestamp not null,
hcl_rn varchar (15) null,
sexo_rn char (2) null,
APGAR varchar (10) null,
cama_rn int null,
diash_rn int null,
telefono_rn varchar (9) null,
direccion_rn varchar (75) null,
acompanante varchar (25) null,
fecha_sali_rn date null,
peso_rn decimal null,
talla_rn decimal null,
pc_rn decimal null,
pt_rn decimal null,
constraint PK_VIDA_NUEVA primary key (apell_rn,hora_naci_rn));
RENAN NAZATE ORTIZ
48
TECNICAS DE PROGRAMACION VISUAL PARA APLICAICIONES DOS CAPAS EN LA PLATAFORMA LINUX
/*#==========================================================
#Tabla paciente para llenar datos del paciente Hospitalizado
#==========================================================
#drop table paciente*/
create table paciente (
cod_paciente varchar(30) not null,
apell_nom_paciente varchar(60) not null,
cc_paciente varchar(10) null,
HCL_paciente varchar(15) default null,
fecha_hora_paciente timestamp not null,
edad_paciente int not null,
sexo_paciente char(1) not null,
estado_civil_paciente varchar(2) not null,
fecha_naci_paciente date null,
direccion_paciente varchar(75) default null,
telefono_paciente varchar(9) default null,
cama_paciente int default null,
dias_hospitalizados int default null,
fecha_egre_paciente date null,
nombre_acompanante varchar(25) default null,
costo varchar(30) default null,
nfactura varchar(30) default null,
constraint PK_PACIENTE primary key (cod_paciente));
--constraint
FK_CIRU_PROCE
foreign
key
(cod_cirugia)
references
procedimiento (cod_cirugia));
/*#====================================================
#Tabla cirugia_paciente para llenar datos
#acerca de datos acerca de la cirugia
#======================================================
#drop table cirugia_paciente*/
create table cirugia_paciente (
cod_paciente varchar(30) not null,
cod_ciru_dere varchar (30) not null,
RENAN NAZATE ORTIZ
49
TECNICAS DE PROGRAMACION VISUAL PARA APLICAICIONES DOS CAPAS EN LA PLATAFORMA LINUX
hora_quiro varchar (30) not null,
dia_hospi varchar (30) not null,
vderqui decimal not null,
vderhos decimal not null,
vderamedi decimal not null,
vtotalquiro decimal not null,
vtotalhos decimal not null,
anestesia_paciente varchar (120) not null,
constraint PK_CIRUGIA primary key (cod_paciente),
constraint FK_CIRU_PACI foreign key (cod_paciente) references paciente
(cod_paciente));
/*#====================================================
#Tabla examenes_laboratorio necesaria para llenar datos
#acerca de los examenes realizados.
#======================================================
#drop table examenes_paciente*/
create table examenes_paciente (
cod_paciente varchar(30) not null,
nombre_examen_laboratorio varchar (60) not null,
cod_exa_labo varchar (30) not null,
presenta varchar (5) not null,
cantidad int not null,
precio_unitario_examen decimal not null,
precio_total decimal not null,
fecha_hora_examen timestamp not null,
constraint
PK_EXAMENES_LABORATORIO
primary
key
(cod_paciente,
nombre_examen_laboratorio, cod_exa_labo),
constraint FK_EXAMLABO_PACIENTE foreign key (cod_paciente) references
paciente (cod_paciente));
/*#====================================================
#Tabla datos_personal_paciente para llenar datos
#acerca de honorarios medicos.
RENAN NAZATE ORTIZ
50
TECNICAS DE PROGRAMACION VISUAL PARA APLICAICIONES DOS CAPAS EN LA PLATAFORMA LINUX
#======================================================
#drop table datos_personal_paciente*/
create table datos_personal_paciente (
cod_paciente varchar (30) not null,
cod_perso_proce varchar (30) not null,
cirujano varchar (60) null,
ayudante varchar (60) null,
anestesista varchar (60) null,
instrumentista varchar (60) null,
circulante varchar (60) null,
pediatra varchar (60) null,
puntosciru decimal null,
puntosayu decimal null,
valpuntos decimal null,
vtotalciru decimal null,
vtotalayu decimal null,
vanestesista decimal null,
vinstru decimal null,
vcirculante decimal null,
vpediatra decimal null,
constraint PK_DATOPERPAC primary key (cod_paciente),
constraint FK_COD_PACI foreign key (cod_paciente) references paciente
(cod_paciente));
/*#====================================================
#Tabla farmacia_paciente para complementar datos
#acerca de todos los datos utilizados de farmacia
#======================================================
#drop table farmacia_paciente*/
create table farmacia_paciente (
cod_paciente varchar (30) not null,
cod_farma_farma varchar (30) not null,
nom_me_in_sele varchar (60) not null,
presenta varchar (10) not null,
RENAN NAZATE ORTIZ
51
TECNICAS DE PROGRAMACION VISUAL PARA APLICAICIONES DOS CAPAS EN LA PLATAFORMA LINUX
cant_utilizada decimal not null,
valor_unit decimal not null,
valor_total decimal not null,
diferencia varchar (40) not null,
constraint
PK_FARMACIA_PAC
primary
key
(cod_paciente,cod_farma_farma,diferencia),
constraint FK_CO_PACIENT foreign key (cod_paciente)
references paciente (cod_paciente));
insert into usua_previ values ('Administrador','hcsjobrero','Administrador');
MySQL
MySQL es una base de datos muy popular. Es un servidor multi-hilos de bases
de datos de código abierto, confiable, rápido, compacto, poderoso y
multiplataforma podemos hacer las bases de datos a código abierto.
Una gran ventaja es que se puede utilizar gratis y su código fuente siempre
esta disponible.
Características:
 El principal objetivo de MySQL es la velocidad y robustez.
 Esta escrito en C y C++, testado con GCC 2.7.2.1. Usa GNU autoconf
para su portabilidad.
 Posee clientes C, C++, Java, Perl, TCL, etc.
 Es multiproceso, es decir puede usar varias CPU si éstas están
disponibles.
 Puede trabajar en distintas plataformas y Sistemas Operativos (SO)
distintos.
RENAN NAZATE ORTIZ
52
TECNICAS DE PROGRAMACION VISUAL PARA APLICAICIONES DOS CAPAS EN LA PLATAFORMA LINUX
 Su sistema de contraseñas y privilegios es muy flexible y seguro.
 Tiene registros de longitud fija y variable.
 Tiene 16 índices por tabla, cada índice puede estar compuesto de 1 a
15 columnas o partes de ellas con una longitud máxima de 127 bytes.
 Todas las columnas pueden tener valores por defecto.
 Todos los datos están grabados en formato ISO8859_1.
 Los clientes usan TCP o UNIX Socket para conectarse al servidor.
 El servidor soporta mensajes de error en distintas lenguas.
 Todos los comandos tienen -help o -? Para las ayudas.
 Diversos tipos de columnas como enteros de 1, 2, 3, 4, y 8 bytes, coma
flotante, doble precisión, carácter, fechas, enumerados, etc. [www-13]
Como un ejemplo claro de la utilización del código MySQL es el siguiente
ejemplo en la realización de la base de datos para el sistema del Hospital
Comunitario “San José Obrero”.
#=====================================================
#Sistema de bases para el hospital "San José Obrero"
#create database paquetes_quirurgicos;
#====================================================
#===========================================================
# Table: USUARIO
#===========================================================
#drop table usuario
create table usua_previ (
RENAN NAZATE ORTIZ
53
TECNICAS DE PROGRAMACION VISUAL PARA APLICAICIONES DOS CAPAS EN LA PLATAFORMA LINUX
usuario varchar(40) not null,
contras varchar(30) not null,
previle varchar(30) not null,
constraint PK_PREV_US primary key (usuario));
#====================================================
#Tabla medicamentos_farmacia necesaria para llenar datos
#acerca de los medicinas utilizados
#======================================================
#drop table farmacia
create table farmacia (
cod_medi_insu_farmacia varchar (30) not null,
nombre_comer_insumo_medicamento varchar (60) not null,
nombre_generico_medicamento varchar (60) default null,
precio_unitario double not null,
presentacion char (6) not null,
stock_insu_medicamento int not null,
cant_llevada double default '1' not null,
cant_llevada_unit double not null,
fecha_adquisicion date not null,
fecha_caducidad date not null,
constraint
PK_MEDICAMENTOS_FARMACIA
primary
(cod_medi_insu_farmacia));
#====================================================
#Tabla procedimiento para llenar datos
#acerca de datos acerca del procedimiento
#======================================================
#drop table procedimiento
create table procedimiento (
cod_cirugia varchar (30) not null,
procedimiento_cirugia varchar (60) not null,
num_puntos_ci double null,
num_puntos_ay double null,
RENAN NAZATE ORTIZ
54
key
TECNICAS DE PROGRAMACION VISUAL PARA APLICAICIONES DOS CAPAS EN LA PLATAFORMA LINUX
valor_puntos double null,
valor_total_ciru double not null,
valor_total_ayu double not null,
valor_apro double null,
constraint PK_PROCEDI primary key (cod_cirugia));
#=====================================================
#Tabla recien_nacido para llenar datos del niño nacido
#======================================================
create table recien_nacido (
cod_rn varchar (30) not null,
apell_rn varchar (40) not null,
hora_naci_rn datetime not null,
hcl_rn varchar (15) null,
sexo_rn char (2) null,
APGAR varchar (10) null,
cama_rn int null,
diash_rn int null,
telefono_rn varchar (9) null,
direccion_rn varchar (75) null,
acompanante varchar (25) null,
fecha_sali_rn date null,
peso_rn double null,
talla_rn double null,
pc_rn double null,
pt_rn double null,
constraint PK_VIDA_NUEVA primary key (apell_rn,hora_naci_rn));
#====================================================
#Tabla datos_personal para llenar datos
#acerca de Medicos, enfermeras, etc.
#======================================================
#drop table datos_personal
create table datos_personal (
RENAN NAZATE ORTIZ
55
TECNICAS DE PROGRAMACION VISUAL PARA APLICAICIONES DOS CAPAS EN LA PLATAFORMA LINUX
cc_personal varchar (10) not null,
nombre_personal varchar (60) not null,
telef_personal varchar (9) default null,
direccion varchar (75) default null,
edad int default null,
especialidad varchar (25) default null,
constraint PK_DAT_PERSON primary key (cc_personal));
#==========================================================
#Tabla paciente para llenar datos del paciente Hospitalizado
#==========================================================
#drop table paciente
create table paciente (
cod_paciente varchar(30) not null,
apell_nom_paciente varchar(60) not null,
cc_paciente varchar(10) null,
HCL_paciente varchar(15) default null,
fecha_hora_paciente datetime not null,
edad_paciente int not null,
sexo_paciente char(1) not null,
estado_civil_paciente varchar(2) not null,
fecha_naci_paciente date null,
direccion_paciente varchar(75) default null,
telefono_paciente varchar(9) default null,
cama_paciente int default null,
dias_hospitalizados int default null,
fecha_egre_paciente date default null,
nombre_acompanante varchar(25) default null,
costo varchar(30) default null,
nfactura varchar(30) default null,
constraint PK_PACIENTE primary key (cod_paciente),
constraint
FK_CIRU_PROCE
foreign
procedimiento (cod_cirugia));
RENAN NAZATE ORTIZ
56
key
(cod_cirugia)
references
TECNICAS DE PROGRAMACION VISUAL PARA APLICAICIONES DOS CAPAS EN LA PLATAFORMA LINUX
#====================================================
#Tabla cirugia_paciente para llenar datos
#acerca de datos acerca de la cirugia
#======================================================
#drop table cirugia_paciente
create table cirugia_paciente (
cod_ciru_paci varchar (30) not null,
cod_ciru_dere varchar (30) not null,
hora_quiro varchar (30) not null,
dia_hospi varchar (30) not null,
vderqui double not null,
vderhos double not null,
vderamedi double not null,
vtotalquiro double not null,
vtotalhos double not null,
anestesia_paciente varchar (120) not null,
constraint PK_CIRUGIA primary key (cod_ciru_paci),
constraint FK_CIRU_PACI foreign key (cod_paciente) references paciente
(cod_paciente));
#====================================================
#Tabla examenes_laboratorio necesaria para llenar datos
#acerca de los examenes realizados.
#======================================================
#drop table examenes_paciente
create table examenes_paciente (
cod_exa_paci varchar (30) not null,
nombre_examen_laboratorio varchar (60) not null,
cod_exa_labo varchar (30) not null,
presenta varchar (5) not null,
cantidad int not null,
precio_unitario_examen double not null,
precio_total double not null,
fecha_hora_examen datetime not null,
RENAN NAZATE ORTIZ
57
TECNICAS DE PROGRAMACION VISUAL PARA APLICAICIONES DOS CAPAS EN LA PLATAFORMA LINUX
constraint
PK_EXAMENES_LABORATORIO
primary
key
(cod_exa_paci,
nombre_examen_laboratorio, cod_exa_labo),
constraint FK_EXAMLABO_PACIENTE foreign key (cod_paciente) references
paciente (cod_paciente));
#====================================================
#Tabla datos_personal_paciente para llenar datos
#acerca de honorarios medicos.
#======================================================
#drop table datos_personal_paciente
create table datos_personal_paciente (
cod_perso_paci varchar (30) not null,
cod_perso_proce varchar (30) not null,
cirujano varchar (60) null,
ayudante varchar (60) null,
anestesista varchar (60) null,
instrumentista varchar (60) null,
circulante varchar (60) null,
pediatra varchar (60) null,
puntosciru double null,
puntosayu double null,
valpuntos double null,
vtotalciru double null,
vtotalayu double null,
vanestesista double null,
vinstru double null,
vcirculante double null,
vpediatra double null,
constraint PK_DATOPERPAC primary key (cod_perso_paci,cod_perso_proce),
constraint FK_COD_PACI foreign key (cod_paciente) references paciente
(cod_paciente));
RENAN NAZATE ORTIZ
58
TECNICAS DE PROGRAMACION VISUAL PARA APLICAICIONES DOS CAPAS EN LA PLATAFORMA LINUX
#====================================================
#Tabla farmacia _ paciente para complementar datos
#acerca de todos los datos utilizados de farmacia
#======================================================
#drop table farmacia_paciente
create table farmacia_paciente (
cod_farma_paci varchar (30) not null,
cod_farma_farma varchar (30) not null,
nom_me_in_sele varchar (60) not null,
presenta varchar (10) not null,
cant_utilizada double not null,
valor_unit double not null,
valor_total double not null,
diferencia varchar (40) not null,
constraint
PK_FARMACIA_PAC
primary
key
(cod_farma_paci,cod_farma_farma,diferencia),
constraint FK_CO_PACIENT foreign key (cod_paciente) references paciente
(cod_paciente));
insert into usua_previ values ('Administrador','hcsjobrero','Administrador');
RENAN NAZATE ORTIZ
59
TECNICAS DE PROGRAMACION VISUAL PARA APLICAICIONES DOS CAPAS EN LA PLATAFORMA LINUX
Análisis de las Bases de Datos (Ventajas, Desventajas)
La
información
y
comparativas
existentes
sobre
MySQL
y PostgreSQL para ver cuál DBM puede ser mejor es abundante
pero muy confusa. Se tiene muchos comentarios al respecto, la mayoría de
ellos
catalogables
como
las
que
se
producen
en
comparaciones "Linux vs. Windows", "Mac vs. PC", etc. [www-14]
CUADRO COMPARATIVO DE MySQL Y PostgreSQL
POSTGRESQL
MYSQL
VENTAJAS
Por su arquitectura
de
diseño, Mayor
rendimiento
y
Mayor
escala muy bien al aumentar el velocidad tanto al conectar con el
número de CPUs y la cantidad de servidor como al servir selects y
RAM.
demás.
Soporta transacciones y desde la Mejores utilidades de administración
versión 7.0, claves ajenas (con (backup, recuperación de errores,
comprobaciones
de
integridad etc.).
referencial).
Tiene mejor soporte para triggers y
Aunque se cuelgue, no suele perder
procedimientos en el servidor.
información ni corromper los datos.
Mejor integración con PHP.
No hay límites en el tamaño de los
registros.
Soporta un subconjunto de SQL92 Mejor control de acceso, en el
MAYOR que el que soporta MySQL. sentido de qué usuarios tienen
Además,
tiene
ciertas acceso
a
qué
características orientadas a objetos. qué permisos.
RENAN NAZATE ORTIZ
60
tablas
y
con
las
TECNICAS DE PROGRAMACION VISUAL PARA APLICAICIONES DOS CAPAS EN LA PLATAFORMA LINUX
MySQL se comporta mejor que
Postgres a la hora de modificar o
añadir campos a una tabla "en
caliente".
DESVENTAJAS
Consume más recursos y carga más No soporta transacciones, "roll el sistema.
backs" ni subselects.
Límite del tamaño de cada fila de las
tablas a 8k!!! (Se puede ampliar a No considera las claves ajenas.
32k recompilando, pero con un Ignora
coste añadido en el rendimiento).
la
dejándola
integridad
en
referencial,
manos
Es de 2 a 3 veces más lenta que programador de la aplicación.
MySQL.
Menos funciones en PHP.
RENAN NAZATE ORTIZ
61
del