Introducción a PostgreSQL Un ejemplo sencillo
Tomás Javier Robles Prado Raúl Turienzo Fernández
Introducción a PostgreSQL: Un ejemplo sencillo por Tomás Javier Robles Prado y Raúl Turienzo Fernández
Se autoriza la copia, distribución y/o modificación de este documento según los términos de la GNU Free Documentation License (Licencia de documentación libre GNU), versión 1.1 o cualquier versión posterior publicada por la Free Software Foundation; sin secciones invariables, textos previos o textos finales. Los programas de ejemplo de este documento son software libre; pueden ser redistribuidos y/o modificados según los términos de la licencia de Python publicada por la Python Software Foundation.
Historial de revisiones Revisión 0.01 25-11-2002 Revisado por: tjrp-rtf Documento de partida Revisión 0.10 16-12-2002 Revisado por: tjrp-rtf Documento terminado
Tabla de contenidos 1. Introducción.......................................................................................................................1 2. Empezando.........................................................................................................................3 Consiguiendo e instalando PostgreSQL ...................................................................3 Poniendo en marcha el servidor ................................................................................3 Administración remota con OpenSSH ........................................................................4 3. Describiendo el problema...............................................................................................9 Enunciado del problema .............................................................................................9 Construyendo el diagrama E-R..................................................................................9 Construyendo las tablas ............................................................................................13 Consultando nuestra Base de Datos........................................................................16 Consideraciones finales .............................................................................................17 Observaciones ...................................................................................................17 Semántica no reflejada .....................................................................................18 4. Pgaccess: La herramienta gráfica de PostgreSQL ....................................................19 Introducción a Pgaccess ...........................................................................................19 Utilizando Pgaccess..................................................................................................20 5. Accediendo mediante software: Pycemen ...................................................................25 ¿Por qué Python?........................................................................................................25 Comentando el programa .........................................................................................25 Funcionalidades de Pycemen ..........................................................................25 Pycemen en acción.............................................................................................26 ¿Por qué una interfaz basada en texto? .........................................................28 6. Conclusiones finales.......................................................................................................31 7. ¿Por dónde sigo? .............................................................................................................33 Bibliografía ..................................................................................................................33 Índice.....................................................................................................................................35
iii
iv
Capítulo 1. Introducción En los últimos años, el software de bases de datos ha experimentado un auge extraordinario, a raíz de la progresiva informatización de casi la totalidad de las empresas de hoy día. No es extraño pues, que existan multitud de gestores de bases de datos, programas que permiten manejar la información de modo sencillo. De este modo tenemos Oracle™1, Microsoft SQL Server™2, Borland Interbase™3 entre otras. Las soluciones software que hemos citado son comerciales. Como siempre, en el mundo del software libre, siempre que se necesita algo, tarde o temprano se implementa. Así tenemos MySQL™4, gestor muy usado en la web (combinado con php y apache) o PostgreSQL™5, que será el gestor que trataremos 6 . Como hemos comentado, PostgreSQL es software libre. Concretamente está liberado bajo la licencia BSD, lo que significa que cualquiera puede disponer de su código fuente, modificarlo a voluntad y redistribuirlo libremente 8, PostgreSQL además de ser libre es gratuito y se puede descargar libremente de su página web para multitud de plataformas. La versión actual de PostgreSQL es la 7.3, liberada el 27 de Noviembre de 2002 y puede descargarse libremente desde su sitio oficial9. Incluso, si se tiene curiosidad, se puede bajar un fichero de audio con la pronunciación correcta10 de PostgreSQL.
Notas 1. http://www.oracle.com 2. http://www.microsoft.com/sql/default.asp 3. http://www.borland.com/interbase/index.html 4. http://www.mysql.com 5. http://www.postgresql.org 6. Existe una interesante 7. http://www.mmlabx.ua.es/mysql-postgres.html . Viene a decir que PostgreSQL es superior en BBDD "a lo grande", mientras que para conjuntos de datos pequeños o medianos MySQL gunciona mejor. 7. http://www.mmlabx.ua.es/mysql-postgres.html 8. Es más, la licencia BSD permite redistribuir el código modificado o no como software cerrado, en contraposición a la licencia GPL que fuerza a que las modificaciones sean publicadas también bajo la GPL. 9. http://www.postgresql.org 10. http://www.fr.postgresql.org/postgresql.mp3
1
Cap铆tulo 1. Introducci贸n
2
Capítulo 2. Empezando Consiguiendo e instalando PostgreSQL Vamos a describir el proceso de instalación de PostgreSQL para Linux. En nuestro caso hemos utilizado la distribución RedHat™ 8.0. RedHat™ utiliza un sistema de gestión de paquetes denominado RPM que permite instalar fácilmente el gestor de base de datos. Además PostgreSQL viene incluido en la distribución estándar por lo que simplemente hemos de instalar los paquetes q nos interesen: [jav@cable213a078 jav]$ rpm
-Uvh postgresql-7.2.2-1.i386.rpm
En caso de no usar distribuciones basadas en RPM o simplemente por gusto, podemos bajar el código fuente de PostgreSQL de su web1. Una vez bajado, lo descomprimimos, [jav@cable213a078 jav]$ tar xvzf
postgresql-7.2.2-1.tar.gz
nos movemos al directorio resultante y ejecutamos el script de configuración. 2 [jav@cable213a078 postgresql]$
./configure
Si todo ha ido bien, es hora de compilar. Para ellos ejecutaríamos [jav@cable213a078 postgresql]$ make
y si no hay errores, nos logueamos como root y ejecutamos [root@cable213a078 postgresql]# make install
Y ya tenemos PostgreSQL instalado en nuestro equipo.
Poniendo en marcha el servidor Veamos ahora cómo hacer funcionar el servidor de base de datos. Lo primero es fijar la variable de entorno que almacenará la ruta hasta el directorio donde guardaremos la información de la base de datos: [jav@cable213a078 postgresql]$ export PGDATA=/el/path/deseado/data
En nuestro caso: [jav@cable213a078 postgresql]$ export PGDATA=/home/jav/db/data
El siguiente paso es crear las estructuras necesarias para iniciar el servidor de la base de datos. Esto se consigue con la orden initdb: [jav@cable213a078 postgresql]$ initdb The files belonging to this database system will be owned by user "jav". This user must also own the server process. Fixing permissions on existing directory /home/jav/db/data... ok creating directory /home/jav/db/data/base... ok creating directory /home/jav/db/data/global... ok creating directory /home/jav/db/data/pg_xlog... ok creating directory /home/jav/db/data/pg_clog... ok creating template1 database in /home/jav/db/data/base/1... ok creating configuration files... ok
3
Capítulo 2. Empezando initializing pg_shadow... ok enabling unlimited row size for system tables... ok creating system views... ok loading pg_description... ok vacuuming database template1... ok copying template1 to template0... ok Success. You can now start the database server using: /usr/bin/postmaster -D /home/jav/db/data or /usr/bin/pg_ctl -D /home/jav/db/data -l logfile start
Siguiendo las instrucciones que amablemente nos da initdb iniciamos el servidor, añadiendo los parámetros -i (para admitir conexiones TCP/IP, ya lo explicaremos más adelante) y -o para obtener formato de fechas europeo en nuestra base de datos: [jav@cable213a078 db]$ /usr/bin/postmaster -o -i -D /home/jav/db/data &
Tras algunos mensajes de depuración, tenemos el servidor corriendo en nuestra máquina. Ahora crearemos una base de datos para ver que la cosa marcha: [jav@cable213a078 db]$createdb pepa CREATE DATABASE
Como nos hemos quedado un poco fríos con la respuesta de PostgreSQL vamos a ver si podemos hacer algo con esta base de datos: [jav@cable213a078 db]$ psql pepa Welcome to psql, the PostgreSQL interactive terminal. Type:
\copyright for distribution terms \h for help with SQL commands \? for help on internal slash commands \g or terminate with semicolon to execute query \q to quit
pepa=# create table provincias(prefijo integer, nombre varchar(20)); CREATE pepa=# insert into provincias values(987, ’León’); INSERT 16559 1 pepa=# insert into provincias values(91, ’Madrid’); INSERT 16560 1 pepa=# insert into provincias values(923, ’Salamanca’); INSERT 16561 1 pepa=# select * from provincias; prefijo | nombre ---------+----------987 | León 91 | Madrid 923 | Salamanca (3 rows)
Pues bueno, parece que la cosa funciona. Ya tenemos todo en marcha y funcionando. En adelante pasaremos a cosas mayores.
4
Capítulo 2. Empezando
Administración remota con OpenSSH En este apartado veremos cómo acceder a un máquina remota (donde está corriendo la base de datos) de modo seguro para administrarla. Para ello utilizaremos ssh que permite establecer conexiones entre máquinas de modo que toda la información que intercambien vaya encriptada. Lo primero es habilitar el servidor ssh en la máquina a la que pretendamos acceder.ssh utiliza el puerto 22 para las comunicaciones. Una vez cumplido este paso, ya estamos listos para aceptar conexiones remotas. Ya hemos configurado lo necesario del lado del servidor. Veamos ahora los pasos necesarios del lado del cliente. Distinguiremos entre máquinas Linux y Windows 3 . •
En Linux (o Unix) posiblemente ya tengamos el cliente ssh instalado. Si no es así nos dirigiremos al sitio oficial de OpenSSH4 de donde bajaremos los fuentes, los compilaremos e instalaremos. Dependiendo de la distribución que usemos será más fácil o más difícil encontrar paquetes precompilados que nos ahorren el trabajo. Suponiendo que ya tenemos el cliente instalado, es hora de acceder a la máquina remota. Sin entrar en detalles, diremos que basta con: [jav@cable213a078 jav]$ ssh bbdd@212.183.213.178 bbdd@212.183.213.178’s password: Esta cuenta aloja el trabajo de BBDD Directorios: -datos: Contiene los ficheros de la base de datos -docbd: Contiene los fuentes de la documentación y la documentación en sí. Ejecute make single-html para documentación en un único html o make multiple-html para documentación en varios html. -programa: Contiene el código del programa que acceda a la BBDD Cualquier duda puede remitirla a tjavier@usuarios.retecal.es o rtf@usuarios.retecal.es [bbdd@cable213a078 bbdd]$
Genéricamente basta con ssh login@IP y se nos pedira el password. Una vez introducido, ya estaremos trabajando en la máquina remota y todo lo que hagamos se ejecutará en ella: [bbdd@cable213a078 bbdd]$ ls datos docbd programa
•
En Windows actuaremos de un modo similar. Lo primero será bajar PuTTY5, un cliente para conexiones ssh en windows. PuTTY tiene una interfaz amigable, en la que sólo tendremos que especificar la IP a la que conectarnos en indicar que pretendemos hacer una conexión ssh:
El aspecto de PuTTY funcionando es similar al de una consola de Unix. Tras un rato trabajando con PuTTY se nos olvidará que estamos utilizando Windows.
5
Capítulo 2. Empezando
En ocasiones será necesario mover archivos de nuestra máquina local a la remota o viceversa. En Windows existe una aplicación que proporciona una interfaz de usuario a scp (secure copy). Esta aplicación de llama WinSCP6 y es también muy sencilla de usar, con una configuración muy intuitiva:
Hemos descrito herramientas que nos servirán para conectarnos a la máquina que aloje la base de datos. Esto será útil para administrarla sin estar físicamente junto a ella y ayuda a que diferentes personas trabajen sin molestarse (n manos teclean más que 2). 6
Capítulo 2. Empezando
Notas 1. http://www.postgresql.org 2. Si algo va mal, o tiene necesidades especiales (un directorio diferente del estándar, compilación para otras arquitecturas...) debería ejecutar [jav@cable213a078 postgresql]$ ./configure --help
y observar la salida.
3. Las IPs que aparecen en los ejemplos son inventadas (obviamente). 4. http://www.openssh.com/ 5. http://www.chiark.greenend.org.uk/~sgtatham/putty/download.html 6. http://winscp.vse.cz/eng/download.php
7
CapĂtulo 2. Empezando
8
Capítulo 3. Describiendo el problema Enunciado del problema Se desea implementar una base de datos para facilitar la gestión y administración de un cementerio, en dicha base de datos se contemplan diferentes categorías laborales, distintos tipos de enterramiento, facturas por los servicios prestados, incluso se permite que una familia posea su propio panteón para un determinado número de personas. El cementerio está dividido en sectores, teniendo estos una capacidad y extensión variable que ha de quedar reflejada. Asimismo se ha quiere tener información sobre los empleados mediante datos personales como nombre y apellidos,dirección, telefóno, salario, antigüedad, etc. Las categorías en las que se dividen los empleados son: •
Enterradores
•
Jardineros
•
Administrativos
Los jardineros se ocuparán del cuidado de los sectores, de tal forma que un jardinero está al cuidado de un sector, aunque del cuidado de un sector pueden encargarse varios jardineros. Asimismo,cada sector contendrá un determinado número de tumbas.Una tumba pertenece a un sector. Las Tumbas pueden ser de uno de los siguientes tipos: •
Nicho
•
Panteón
•
Fosa Común
Es necesario, además, almacenar información sobre el fallecido, así como de la persona (familiar) que se hará cargo de los costes del servicio (todo ello, obviamente identificado mediante los datos personales y de interés para la empresa). •
Cada fallecido es enterrado por un único enterrador,lógicamente el enterrador puede enterrar a mas de un fallecido durante su jornada laboral.
•
Los nichos tienen capacidad para una sola persona.
•
Sin embargo un panteón tiene capacidad para varias personas siendo lo normal 4, siendo por eso de tipo smallint.
•
La capacidad de una Fosa Común es superior a la de un panteón, y es de tipo integer. En este caso y en los dos anteriores asumimos la indivisibilidad del fallecido.
Además, los administrativos emiten facturas para los familiares, de tal forma que un administrativo puede emitir facturas a varios familiares, y un familiar puede recibir varias facturas El único tipo de tumba que puede ser propiedad de un familiar es el panteón, siendo propiedad de una única persona, y dicha persona puede poseer varios panteones.
9
Capítulo 3. Describiendo el problema
Construyendo el diagrama E-R Para realizar el diagrama de entidad-relación hemos de decidir los conjuntos tanto de entidades como de relaciones, atendiendo al enunciado del problema, la estructura del diagrama ha quedado como sigue: •
Entidades: 1. Empleado (que constará a su vez de tres tipos: Jardinero, Enterrador y Administrativo). 2. Sector (en los que está dividido el cementerio). 3. Tumba (puede ser de tres tipos: Nicho, Panteón y Fosa Común). 4. Fallecido (Representa a la persona muerta mediante los atributos detallados mas tarde). 5. Familiar (Es necesario enviar la factura a los familiares del fallecido).
•
Relaciones: 1. JarSec ( Indica la relación de los jardineros con los sectores del cementerio) 2. TumSec (Relación que se da entre las tumbas y los sectores en que están ubicadas) 3. EnFa (Es la relación que se establece entre los enterradores y los fallecidos). 4. Factura (Representa la venta de una tumba a la familia del fallecido). 5. NiFa (Indica si el fallecido tiene asignado un Nicho). 6. FoFa (Indica si el fallecido se encuentra en una Fosa Común). 7. PanFa (Indica si el fallecido se encuentra en un Panteón). 8. FamFa (Es la relación establecida entre el fallecido y su familia). 9. PaFam (Relación que indica la posesión de un panteón por parte de una familia).
A continuación hablaremos de los pormenores tanto de las entidades como de las relaciones, especificando atributos, tipos de relaciones, cardinalidades y todo aquello que sea interesante destacar. Comenzamos pues por los atributos propios de cada entidad: La entidad Familiar tiene 5 atributos: •
Nombre: Nombre del familiar al que se envía la factura.
•
Apellidos: Contiene los apellidos del familiar.
•
Telefono: Teléfono de contacto del familiar.
•
Direccion: Almacena la dirección (calle, numero, piso, etc).
•
ID_Familia: Código identificador de un familiar, es la clave primaria de esta tabla.
La entidad Enterrador tiene 8 atributos:
10
•
Nombre: Representará el nombre del empleado.
•
Apellidos: Contienen los apellidos del empleado.
•
Dirección: Almacena la dirección (calle, numero, piso, etc).
•
Teléfono: Número de teléfono de contacto.
•
Telef_Movil: Número de teléfono móvil.
Capítulo 3. Describiendo el problema •
Antigüedad: Años de servicio en la empresa.
•
Salario: Sueldo en Euros .
•
DNI: Contiene el número del DNI, es la clave primaria de esta entidad.
La entidad Administrativo tiene 8 atributos: •
Nombre: Representará el nombre del empleado.
•
Apellidos: Contienen los apellidos del empleado.
•
Dirección: Almacena la dirección (calle, numero, piso, etc).
•
Teléfono: Número de teléfono de contacto.
•
Telef_Movil: Número de teléfono móvil.
•
Antigüedad: Años de servicio en la empresa.
•
Salario: Sueldo en Euros .
•
DNI: Contiene el número del DNI, es la clave primaria de esta entidad.
La entidad Sector tiene 4 atributos: •
Nombre: Nombre de cada sector o zona del cementerio.
•
ID_Sector: Código identificador de zona
•
Superficie: Extensión en m2
•
Capacidad: Número de fallecidos que puede alojar.
La entidad Jardinero tiene 9 atributos: •
Nombre: Representará el nombre del empleado.
•
Apellidos: Contienen los apellidos del empleado.
•
Dirección: Almacena la dirección (calle, numero, piso, etc).
•
Teléfono: Número de teléfono de contacto.
•
Antigüedad: Años de servicio en la empresa.
•
Salario: Sueldo en Euros
•
Sector: El sector del cementerio donde trabaja. Clave ajena tomada de Sector.
•
DNI: Contiene el número del DNI, es la clave primaria de esta entidad.
La entidad Tumba tiene 4 atributos: •
ID_Tumba: Código identificadore de tumba.
•
Tipo: Puede ser de tres tipos: Nicho, Panteón o Fosa Común.
•
Sector: Sector en que se encuentra la tumba. Clave ajena tomada de Sector.
La entidad Nicho tiene 3 atributos: •
Altura: Altura del nicho
•
ID_Nicho: Código identificador de nicho. Clave primaria y Clave Ajena tomada de Tumba (ID_Tumba).
•
Inscripcion: Texto que figura en el.
La entidad FosaComun tiene 3 atributos: •
ID_Fosa: Código identificador de Fosa Común. Clave primaria y Clave Ajena tomada de Tumba (ID_Tumba). 11
Capítulo 3. Describiendo el problema •
Capacidad: Número de fallecidos que puede contener.
La entidad Panteon tiene 4 atributos: •
ID_Panteon: Código identificador de panteon. Clave primaria y Clave Ajena tomada de Tumba (ID_Tumba).
•
ID_Familia: Código identificador de familia Clave ajena tomada de Familiar (ID_Familia).
•
Inscripcion: Texto que figura en el.
•
Capacidad: Número de fallecidos que puede contener.
La entidad Factura tiene 5 atributos: •
Cantidad: Total a pagar por la familia.
•
Fecha: Fecha en que se emite la factura.
•
Clave_Factura: Clave primaria (Fecha,ID_Familia,ID_Admin).
•
ID_Familia: Código identificador de familia. Clave ajena tomada de Familiar.
•
ID_Admin:Código identificador de Administrativo. Clave ajena tomada de Administrativo (DNI).
La entidad Fallecido tiene 7 atributos: •
Nombre: Representará el nombre del fallecido.
•
Apellidos: Contienen los apellidos del fallecido.
•
FechaNacimiento: Almacena la fecha de nacimiento del fallecido.
•
FechaMuerte: Almacena la fecha de la muerte del fallecido.
•
Enterrador: Código q identifica al enterrador encargado del entierro. Clave Ajena tomada de Enterrador (DNI).
•
ID_Familia: Código q identifica a la familia del fallecido. Clave Ajena tomada de Familiar (ID_Familia).
•
Tumba: Código q identifica la tumba del fallecido. Clave Ajena tomada de Tumba (ID_Tumba).
Para la realización del esquema Entidad-Relación, hemos utilizado una herramienta para el diseño de diagramas muy conocida por los usuarios de Linux como es Dia , se puede descargar en su versión para Windows 95/98/NT/ME/XP... de este web1 El único inconveniente que hemos observado, es la notación que utiliza para la representación de los atributos, enmarcándolos en una elipse.Debido a esto, decidimos representar en el diagrama sólo los atributos que son clave primaria (para consultar detalles sobre atributos, ver lista anterior)
12
Capítulo 3. Describiendo el problema
Por lo que se refiere a la especialización de la entidad Empleado, podemos decir que consta de tres tipos: Jardinero, Enterrador y Administrativo. En cuanto a la ligadura, diremos que se trata de conjuntos de entidades disjuntos cuya ligadura de completitud es de tipo total, posee además un atributo llamado Tipo que identifica cada una de las tres categorías. La entidad Tumba también posee una especialización en la que se diferencian tres tipos de subclases, a saber: Nicho, Panteón y Fosa Común, se trata de entidades disjuntas cuya participación es total, al pasarlo a tablas aparecerá un atributo en la tabla Tumba q identificará el tipo de Tumba de q se trata.
Construyendo las tablas Una vez obtenido el esquema relacional es sencillo pasarlo a tablas. Nos ayudaresmo de PgAccess, una aplicación gráfica que permite gestionar Postgres de un modo sencillo. Más adelante comentaremos un poco PgAccess En la figura no indicamos campos no nulos ni las claves primarias. De cualquier modo, el resultado es lo bastante claro como para hacernos una idea de la estructura que tendrá la bbdd. 13
CapĂtulo 3. Describiendo el problema
14
CapĂtulo 3. Describiendo el problema
15
Capítulo 3. Describiendo el problema Una vez conseguido este esquema pasamos a plasmarlo a comandos SQL. El resultado se puede observar en este fichero2.
Consultando nuestra Base de Datos En esta sección mostraremos la manera de realizar consultas en la base de datos cementerio mediante unos ejemplos, tomados bien como capturas de Putty para ilustrar la posibilidad de administración remota, bien como salida de pantalla . Como primer ejemplo pondremos una captura directamente de Putty de una consulta que muestra todos los campos de la tabla Familiar.
A continuación mostramos otra captura tomada también de Putty en la que se relacionan nombres y apellidos de Familiares y Fallecidos, como puede observarse, es una consulta que afecta a dos tablas relacionadas por el campo ID_Familia.
Un ejemplo de lo laborioso que puede resultar hacer una consulta para conocer el Dni del enterrador que se ocupó de un fallecido llamado Restituto cementerio=# select Fallecido.Nombre, Fallecido.Apellidos, Enterrador.Dni cementerio-# From Fallecido INNER JOIN Enterrador cementerio-# ON Fallecido.Enterrador = Enterrador.Dni cementerio-# WHERE Fallecido.Nombre = ’Restituto’; nombre
|
apellidos
|
dni
-----------+----------------+---------Restituto | Gracia de Dios | 10657493 (1 row)
Ejemplo que muestra la salida de una consulta para listar el nombre de aquellos enterradores cuyo sueldo sea superior a 1600 Euros cementerio=# select Nombre, Apellidos, Salario cementerio-# FROM Enterrador
16
Capítulo 3. Describiendo el problema
cementerio-# WHERE Salario > 1600; nombre
|
apellidos
| salario
---------+-------------------+--------Marc
| Pérez
| 1800.00
Gonzalo | González González | 1900.00 Luis
| Anté Bajo
| 1750.00
Frutos
| Rojo del Bosque
| 1869.25
(4 rows)
Veamos ahora el uso de Alias para las columnas, mientras que en SQL es sufiente con ponerlo a continuacion del campo o con comilla doble, en PostgreSQL es necesario utilizar as de la siguiente manera: cementerio=# SELECT Nombre as "Nombre de Pila", Apellidos,Dni as "Código Indentificador" cementerio-# FROM Enterrador; Nombre de Pila |
apellidos
| Código Indentificador
----------------+-------------------+----------------------Juán Felipe
| García Sierra
| 71659874
Marc
| Pérez
| 71545545
Jacinto
| Rodríguez López
| 10657493
Gonzalo
| González González | 71234321
Luis
| Anté Bajo
| 9632236
Frutos
| Rojo del Bosque
| 10653298
(6 rows)
Consideraciones finales En este apartado, trataremos temas como la semántica no reflejada en el diseño, los controles que se realizan mediante la aplicación de acceso a la base de datos así como todos aquellos aspectos y consideraciones que no tienen cabida en otros apartados.
Observaciones Como puede apreciarse en el esquema, los fallecidos están relacionados tanto con Nicho como con Panteón y Fosa Común, esto nos obligó a crear la tabla Tumba con un campo llamado Tipo que indicará si la tumba en cuestión es Nicho, Panteón o Fosa Común. Este campo resulta muy útil para realizar consultas que necesiten saber el tipo de enterramiento. No hemos considerado la posibilidad de que una familia pueda ser la propietaria del nicho de su familiar fallecido, dejando esta relación sólo para los panteones. Obviamente no ha sido por comodidad, pues el trabajo añadido sería ínfimo, sino que lo 17
Capítulo 3. Describiendo el problema que nos interesaba era conseguir la mayor variedad posible dentro de unos límites razonables. Además de lo anterior, decidimos que el entierro en fosa común no generase una factura, siendo este un servicio gratuito. Aunque quizá fuera más propio decir esto en el apartado de conclusiones finales y a pesar de que se ha mencionado en varias ocasiones,hemos de hacer hincapié en la forma de trabajo conjunta entre las dos máquinas, una con Linux RedHat 8.0 (donde está alojada la base de datos y el resto del material del trabajo) y otra con Windows 98 desde donde se pueden realizar las tareas necesarias para administrar la base de datos y trabajar en la documentación (haciendo algún que otro malabarismo).
Semántica no reflejada Como puede apreciarse viendo tanto el modelo de Entidad-Relación como el diagrama de tablas, pueden darse casos un tanto extraños como que a dos fallecidos se les asigne el mismo nicho. También se puede exceder la capacidad tanto de Panteones como de Fosas Comunes, no obstante estos problemas son controlados mediante software por la aplicación en Python pycemen, así nos aseguramos de que un nicho sólo pueda estar ocupado por un fallecido, que un panteón pueda contener como máximo a 6 (pueden ser menos) personas así como que una fosa común albergue un máximo de 200 personas (pueden ser menos). Asímismo se observa que los fallecidos pueden pasar indistintamente a un Nicho, Fosa Común o Panteón, sin que aparentemente haya una razón para decidir mas allá de las económicas o de cualquier otro tipo.
Notas 1. http://dia-installer.sourceforge.net/ 2. ../others/cemen_check.sql.html
18
Capítulo 4. Pgaccess: La herramienta gráfica de PostgreSQL Introducción a Pgaccess Hasta ahora, hemos realizado toda la configuración de Postgres mediante órdenes en una línea de comandos. Esto suele intimidar a algunos usuarios (los no acostumbrados a sistemas Unix). Para ellos se desarrolló una potente herramienta, llamada pgaccess. Está programado utilizando las librerías tcl/tk por lo que puede correr en cualquier plataforma a la que haya sido portado tcl/tk (Windows, Unix, Mac...). Pgaccess es libre como todo el software que estamos utilizando. Si quiere más información puede consultar su página en pgaccess.org1. Un detalle importante para utilizar pgaccess es que a la hora de poner en marcha el servidor Postgres hemos de habilitar conexiones a dicho servidor por TCP/IP, ya que pgaccess utiliza este tipo de conexión. El modo de hacer esto es añadir el parámetro -i al iniciar el servidor. Pgaccess permite hacer casi de todo. Desde crear tablas y modificarlas hasta realizar
esquemas de la bbdd. Nosotros sólo veremos una pequeña muestra de su potencia. Incluso incluye un diseñador visual para realizar consultas, uno de formularios y otro de informes. Aquí está la pantalla que muestra las tablas presentes en nuestra bbdd cementerio:
19
Capítulo 4. Pgaccess: La herramienta gráfica de PostgreSQL
Utilizando Pgaccess Veamos ahora de lo que es capaz pgaccess. Vamos a realizar una sencilla consulta para averiguar qué enterradores han enterrado a qué muertos. Según nuestro esquema, esto implica una consulta sobre dos tablas, la de fallecidos y la de muertos. Arrancamos el generador visual de consultas y arrastramos los campos que necesitamos al formulario:
20
CapĂtulo 4. Pgaccess: La herramienta grĂĄfica de PostgreSQL
Una vez configurada nuestra consulta, podemos ver la sentencia SQL resultante o ejecutarla directamente. Los resultados se presentan del siguiente modo:
21
Capítulo 4. Pgaccess: La herramienta gráfica de PostgreSQL
Esta era una consulta sencilla. Supongamos ahora que algún familiar visita el cementerio. Querrá saber dónde está enterrado su pariente. Realizaremos ahora una vista ya que esta parece una situación habitual. Éste será el esquema que diseñemos para implementar esta consulta:
22
Capítulo 4. Pgaccess: La herramienta gráfica de PostgreSQL
El código SQL resultante de esta consulta sería: select t0."nombre", t0."apellidos", t1."nombre", t1."apellidos", t2."id_tumba", t2."tipo", t3."nombre" from "fallecido" t0,"familiar" t1,"tumba" t2,"sector" t3 where (t2."id_tumba"=t0."tumba") and (t3."id_sector"=t2."sector") and (t1."id_familia"=t0."id_familia")
Los resultados de esta consulta serán: 23
Capítulo 4. Pgaccess: La herramienta gráfica de PostgreSQL
Esto es sólo una pequeña muestra de lo que pgaccess puede hacer. No comentaremos aquí el editor de formularios, el de "Reportes" (más bien informes), el de gráficas etc.
Notas 1. http://www.pgaccess.org
24
Capítulo 5. Accediendo mediante software: Pycemen ¿Por qué Python? Python1 es un lenguaje interpretado, orientado a objetos de propósito general. Python
permite mantener de forma sencilla interacción con el sistema operativo, y resulta muy adecuado para manipular archivos de texto. Está disponible en MS-Windows, GNU/Linux, Mac y cualquier entorno *IX. Python es un lenguaje de scripts, sencillo pero potente. Hablamos de scripts pero...¿qué es un script? Un script es un conjunto de instrucciones que se ejecutan paso a paso, instrucción a instrucción. Esto significa que Python no genera ejecutables, si no que es Python el encargado de ejecutar nuestro código. Es por tanto un lenguaje interpretado, no compilado. Esto le dota de ventajas, pero también de algunos inconvenientes: Ventajas •
Desarrollo más rápido : Puedes escribir un programa, salvarlo y ejecutarlo. En un lenguaje compilado tienes que pasar por los pasos de compilar y ligar el software, lo cual puede ser un proceso lento.
•
Multiplataforma : El mismo código funciona en cualquier arquitectura, la única condición es que disponga del intérprete del lenguaje. No es necesario compilar el código una vez para cada arquitectura.
Inconvenientes •
Lentitud : Los programas interpretados son más lentos que los compilados. Sin embargo los programas interpretados suelen ser cortos, en los que la diferencia es inapreciable.
Si desea saber más sobre Python puede consultar Introducción a Python2
Comentando el programa Funcionalidades de Pycemen Lo primero, puede verse el código del programa en este link3. La única funcionalidad de Pycemen es añadir datos a la bbdd. Lo que no es poco. Por ejemplo. Algo sencillo como la adición de un panteón a la base de datos. El programa averigua un código ID_Tumba válido. ¿Cómo? Realizando una consulta a la bbdd, interpretando los resultados y calculando un número que sirva (en este caso no es más que sumarle 1 al último ID_Tumba que exista). Una vez tengamos nuestro ID_Tumba, es necesario saber en qué sector va a ser emplazado. Para ello se realiza 25
Capítulo 5. Accediendo mediante software: Pycemen una consulta en la tabla de sectores y se muestran por pantalla dejando al usuario que decida uno válido. Además es necesario conocer a qué familiar se le va a asociar dicho panteón. Y muchos detalles más. Otro detalle importante es que Pycemen no sólo añade datos en la bbdd, sino que también guarda todas las sentecias SQL de adición de datos que ejecuta. Esto era especialmente importante para nosotros, ya que al ser poco expertos tanto en PostgreSQL como en SQL en ocasiones cometíamos errores que no sabíamos corregir. Como guardábamos un log con todas las sentencias introducidas, nunca tuvimos que lamentar pérdidas de datos (que aunque ficticios, importantes por lo aburrido que resulta añadirlos). Como ejemplo más claro de esto mostramos el siguiente4 fichero generado enteramente por Pycemen.
Pycemen en acción
Vamos a echar un vistazo al funcionamiento al programa. Aunque la versión final puede cambiar (al menos la interfaz) las rutinas que subyacen ya están programadas y funcionan bastante bien (o eso creemos). Veamos cómo es el proceso de añadir un nuevo nicho a nuestra bbdd. Lo primero es acceder al menú de adición de datos, tras lo cual seleccionamos la opción de añadir una nueva tumba. - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
1.- Añadir Enterradores 2.- Añadir Administrativos 3.- Añadir Jardineros 4.- Añadir Tumbas 5.- Añadir Sectores 6.- Añadir Familiar 7.- Añadir Facturas 8.- Añadir Fallecidos 0.- Salir
Seleccione una opción >>> 4
Al seleccionar añadir tumba, el programa calcula un nuevo ID_Tumba que sea coherente con los ya presentes anteriormente y lo muestra en pantalla. A continuación averigua los sectores del cementerio y nos pide que seleccionemos aquel en el que va a ser emplazado el nuevo nicho: ID_Tumba ---> 35 1 Patio de la redención 2 Olvidados del Señor 3 Patio de San Froilán 4 Patio Real 5 La Asunción 6 Los Inocentes 7 Patio de San Isidoro 8 San Judas Tadeo 9 Virgen del Camino 10 El Expolio 11 La Crucifixión Sector ---> 8
26
Capítulo 5. Accediendo mediante software: Pycemen Ahora se nos preguntará el tipo de tumba que queremos añadir (nicho, pateón o fosa común, nicho en este caso), la inscripción visible en el nicho y la altura de éste. Tipo ---> Nicho Inscripción ---> Eternamente Vivo Altura ---> 3 Presione INTRO para continuar
Y ya hemos añadido el nicho. Si observamos el fichero de log donde guardamos todas las sentencias SQL de adición de datos, podemos ver: insert into Tumba Values (35, ’Nicho’ ,8); insert into Nicho Values (3,35,’Eternamente Vivo’);
Y haciendo una consulta a la bbdd: cementerio=# select id_nicho, altura, inscripcion cementerio-# from nicho cementerio-# order by id_nicho; id_nicho | altura | inscripcion ----------+--------+-----------------1 | 1 | 4 | 2 | Salud 27 | 3 | Adiós Camaradas 30 | 2 | er 32 | 2 | 34 | 2 | 35 | 3 | Eternamente Vivo (7 rows)
Este es uno de los ejemplo más sencillos. Se pueden dar situaciones más complicadas como la adición de un fallecido que vaya a ser enterrado en un nicho. En este caso tendremos que cumplimentar además una factura entre otros detalles. Sería algo como esto: Añadiendo Fallecido Nombre ---> Marcos Apellidos ---> Robles de la Huerta Fecha Nacimiento ---> 4/5/56 Fecha Defunción ---> 9/9/02 DNI ---> 9888888 Seleccione Identificador de Enterrador 715451632 Sergio Diez García - Olalla 9248635 Luis Fernández Pérez 71659874 Juan Felipe Garcia Sierra 71632587 Raúl Gómez de la Huerta 71585696 Óscar González Prado 9875651 Pedro Márquez Ruiz 09823456 Segundo Toro de la Tarde Enterrador ---> 715451632 Tipo de Tumba ---> nicho
Hasta aquí todo sencillo. Tan sólo una sencilla consulta para ver los enterradores que tenemos en nómina. Ahora y dado que el fallecido irá a parar a un nicho, hemos de cumplimentar los datos de los familiares. Pude darse el caso de que el familiar que pague la factura sea diferente al que aparezca ligado al fallecido(por ejemplo, en caso de accidente de tráfico, en la factura aparecerá la compañía de seguros). Puede ser que el familiar ya esté en nuestra bbdd o puede ser que no. El programa presenta los posibles familiares y pregunta si se desea añadir una nueva entrada en la tabla de familiares: Seleccione Identificador de Familia 3 Rubén Blanco Gómez 5 Pipo Calceda
27
Capítulo 5. Accediendo mediante software: Pycemen 1 Josu Cordera Láez 4 María de los Dolores Fuertes de Cabeza 2 Nuria González ¿Desea añadir nueva familia? (S/N) n Familia ---> 5
Ahora es el momento de cumplimentar la factura. Se observa el caso que comentamos anteriormente, que en los datos de la factura aparezca un familiar diferente: Añadiendo Factura Cantidad ---> 2000.99 Fecha ---> 9/9/02 Seleccione Identificador familiar 3 Rubén Blanco Gómez 5 Pipo Calceda 1 Josu Cordera Láez 4 María de los Dolores Fuertes de Cabeza 2 Nuria González ¿Desea añadir nueva familia? (S/N) n Familia ---> 5 Seleccione Identificador de Administrativo 9444555 Javier Alto del Cerro 71654321 Joselito de Pequeños Ruiseñores 9636525 Ángeles de todos los Santos Ruiz 71440439 Lucas Feo Gutierrez 71569874 Juaz González Márquez Administrativo ---> 9636525 Presione INTRO para continuar
Ahora que ya hemos cumplimentado e introducido la factura, es hora de elegir un nicho para el difunto. Para ello el programa selecciona de los nichos existentes, los que están libres: Nicho 27 Nicho 32 Nicho 34 Nicho 35 Nicho Presione
libre. Inscripción: libre. Inscripción: libre. Inscripción: libre. Inscripción: ---> 34 INTRO para continuar
Adiós Camaradas Ninguna Ninguna Eternamente Vivo
Fácil, ¿no?
¿Por qué una interfaz basada en texto? Se nos ocurren diversas respuestas a esta pregunta, pero sólo comentaremos las dos más importantes:
28
•
Sólo permitimos accesos locales a la bbdd (precisamente por esto hemos venido usando OpenSSH, para permitir accesos locales desde máquinas remotas. Esta decisión responde a diversas razones, principalmente la seguridad (no somos expertos en PostgreSQL como para permitir a cualquiera el acceso a la bbdd). Bien, ya que todo lo que hagamos se ejecutar en la máquina remota, pensemos que ocurriría si tuviésemos un programa que se ejecutase gráficamente. Nosotros en la máquina remota tendríamos que recibir toda la información gráfica de la aplicación (ventanas, botones, imágenes...) a través de la red. Esto es factible y perfectamente posible en redes LAN con velocidades de 10 Mbps. 5 . Sin embargo a través de una WAN (internet), siendo la velocidad de subida de la máquina que ejecuta el programa de 128Kbps esto no es posible.
•
Velocidad de desarrollo: Hemos preferido añadir funcionalidades a la aplicación que diseñar una interfaz gráfica de usuario (que al fin y al cabo nadie iba a usar). Esta decisión nos ha permitido utilizar el programa aún en fase muy primitiva de
Capítulo 5. Accediendo mediante software: Pycemen desarrollo para añadir datos a la bbdd. Siempre es más cómodo que las sentencias SQL.
Notas 1. http://www.python.org 2. http://users.servicios.retecal.es/tjavier/python/intpython/index.html 3. ../others/cemen.py.html 4. ../others/pycem.dat.html 5. Una muestra se puede ver en 6. http://bulmalug.net/body.phtml?nIdNoticia=1588 . 6. http://bulmalug.net/body.phtml?nIdNoticia=1588
29
CapĂtulo 5. Accediendo mediante software: Pycemen
30
Capítulo 6. Conclusiones finales Después de haber trabajado algo más de un mes con PostgreSQL nos damos cuenta de que es una herramienta mucho más potente y completa de lo que se pudiera pensar en un principio. Hemos empezado de cero, sin apenas haber oido hablar de este gestor (la publicidad la tienen Oracle y MySQL). Rápidamente buscamos en su web instrucciones de cómo instalarlo. Al poco nos dimos cuenta que en los cds de casi cualquier distribución de Linux venía incluido. Una vez instalado, empezamos a trabajar con él. Entonces nos surgió el problema de que una base de datos no es algo tan portable como el código fuente de un programa o un documento, no podíamos meterlo en un disquete o zipearla y enviarla para ver los progresos se cada uno. Teníamos que encontrar el modo de trabajar concurrentemente sobre una base de datos (que al fin y al cabo es uno de los objetivo de los gestores de bases de datos). En tonces se nos ocurrió utlizar conexiones mediante ssh. Así podíamos trabajar sobre la misma base de datos alojada en el ordenador de uno de nosotros. Una vez resueltas con éxito estas cuestiones, empezamos a trabajar en el problema que nos habíamos propuesto. Tras realizar el diagrama Entidad-Realación y pasarlo a tablas, comenzamos a codificarlo en SQL. Aquí se nos presentó otro problema. Aún no sabíamos nada de SQL (sólo habíamos creado bbdd con asistentes visuales de MS-SQLSever™). Entonces con paciencia, manuales y tirando de google hicimos un pequeño boceto. Especialmente traumático fue comprender el uso de los CONSTRAINS para las claves ajenas 1 . Una vez comprendimos esto, hicimos un primer boceto en SQL de nuestra bbdd, que ya incluía tipos de datos y claves primarias y ajenas. Esto nos daría pie a poder empezar a desarrollar el programa que accediera ella. Tras añadir muuuuchos datos (siempre a través de sentencias SQL) empezamos el desarrollo del programa. Elegimos el lenguaje de programación Python, por conocerlo previamente y por lo que necesitábamos en este momento: velocidad de desarrollo y una gran interconectividad con Postgres 2 . El programa avanzaba rápidamente. Decidimos que su única funcionalidad sería la de añadir datos. Que no era una tarea sencilla, debido sobre todo al gran número de relaciones entre las tablas. Por no multiplicar líneas de código, decidimos no realizar demasiadas comprobaciones de error en los datos introducidos. Ya se encargaría de protestar Postgres. A medida que avazábamos nuestros conocimientos en SQL crecían. Realizábamos consultas complejas y empezamos a mejorar el diseño inicial de la bbdd. Afinamos un poco los tipos de datos obtenidos e introdujimos CHECK en muchos atributos y otros detalles. Luego descubrimos que pgaccess podría habernos ahorrado el trabajo de aprender tanto SQL pero siempre es más importante conocer lo que hay que hacer, que dejar a una aplicación que lo haga (sobre todo si no sabemos exactamente lo que esta aplicación hace). Sin embargo hubiera estado bien haber prestado más atención a pgaccess al principio. ¿Qué hemos aprendido? Pues entre otras muchas cosas hemos aprendido a: •
Instalar y configurar un servidor PostgreSQL en un entorno Linux
•
Preparar una máquina Linux para permitir accesos remotos de modo seguro
•
Programar una aplicación que se conecta y utiliza una base de datos
•
Un montón de SQL
•
Utilizar una aplicación gráfica como pgaccess para manipular una bbdd
•
Escribir y compilar documentacion en DocBook/SGML
No queremos olvidarnos de comentar un último detalle muy importante. Todas las aplicaciones que hemos utilizado son software libre (puedes redistribuirlo y modificarlo según sus respectivas licencias) y está disponible de manera gratuita. El coste 31
Capítulo 6. Conclusiones finales por software del problema que hemos descrito e implementado asciende a 0 euros. Eso sí, la mano de obra ha de estar bien remunerada :-)
Notas 1. Es increíble la cantidad de nombres que se les da a las claves ajenas: ajenas, extrajeras, foráneas, externas, exteriores... 2. No sólo de Python vive Postgres evidentemente. Existen módulos de conexión a Postgres para C, Java, Perl, Pascal y un largo etcétera.
32
Capítulo 7. ¿Por dónde sigo? Toda la documentación que hemos utilizado se encuentra en la web. Existen además libros editados de PostgreSQL pero no hemos tenido tiempo de consultarlos (no están en ninguna biblioteca ni librería, una pena). De todos modos, agradecemos a la gente de TLDP-ES/LuCAS1 la recopilación del material referente a Postgres en castellano, así como el el Curso de Bases de Datos y PostgreSQL2.
Bibliografía
Notas 1. http://lucas.hispalinux.es/Postgresql-es/web/ 2. http://lucas.hispalinux.es/Tutoriales/NOTAS-CURSO-BBDD/notas-cursoBD/ 1. http://lucas.hispalinux.es/Tutoriales/NOTAS-CURSO-BBDD/notas-cursoBD/ 2. http://www.sindominio.net/ayuda/postgresql/tutorial-postgresql-1.html 3. http://lucas.hispalinux.es/Postgresql-es/web/navegable/tutorial/tutorial.html 4. http://www.asptutor.com/sql/ 5. http://www.dcc.uchile.cl/~raparede/cc42a/auxSQL/auxSQL.html 6. http://coqui.lce.org/mdejesus/?N=D 7. http://www.commandprompt.com/ppbook/index.lxp 8. http://www.postgresql.org/idocs/index.php?pygresql.html 9. http://www.python.org/doc/current/tut/tut.html 10. http://users.servicios.retecal.es/tjavier/python/intpython/index.html
33
Capítulo 7. ¿Por dónde sigo?
34
23. #AEN172
Índice Apache, 1 BSD, 1 createdb, 4 Formularios, 24 Generador Visual de Consultas, 24 GPL, 1 initdb, 3 Interbase, 1 intérprete, 25 MySQL, 1 Oracle, 1 pgaccess, 20 php, 1 PostgreSQL, 1 PuTTY, 5 Pycemen, 26 Python, 25 RPM, 3 scripts, 25 SQL Server, 1 ssh, 5 Vistas, 24 WinSCP, 6
Notas 1. #INTRODUCCION 2. #INTRODUCCION 3. #AEN118 4. #AEN641 5. #AEN641 6. #INTRODUCCION 7. #AEN118 8. #INTRODUCCION 9. #AEN686 10. #INTRODUCCION 11. #INTRODUCCION 12. #AEN615 13. #INTRODUCCION 14. #INTRODUCCION 15. #AEN172 16. #AEN720 17. #AEN686 18. #AEN77 19. #AEN686 20. #INTRODUCCION 21. #AEN172 22. #AEN641 35