Artículo para la revista Linux Actual número 17: Bases de
datos en WWW con Perl embedido
Miguel Angel Nacenta Sánchez y Javier Fernández-Sanguino
Peña
9 noviembre 2000
En este artículo veremos cómo se puede introducir Perl para la
creación, gestión y mantenimiento de bases de datos a través de la
WWW.
11.. IInnttrroodduucccciióónn
Antes de comenzar se van a repasar algunos de los conceptos vistos ya
en la serie, pero que refrescarán la memoria al lector además de
introducir algunos conceptos nuevos.
Desde que la la WWW decidió que quería ser más interactiva (hace ya
unos cuantos años) y dejar de limitarse a ofrecer contenidos
estáticos, han surgido muchas soluciones que permiten al usuario
interactuar con el sistema. Estas soluciones se pueden separar
claramente en dos tipos; soluciones ejecutadas en el cliente y
soluciones ejecutadas en el servidor. Las primeras (Javascript,
VBscript, applets etc.) fueron un avance considerable en la creación
de lugares Web; pero la mayoría de las aplicaciones serias donde hay
un flujo de información importante no se pueden gestionar de esta
manera.
Por eso hace mucho que existen los CGI scripts, de amplio uso sobre
todo en páginas de servidor que ofrecen algún tipo de servicio en el
que no se puede delegar el control al ordenador del cliente; bien por
motivos de seguridad, o bien por razones de eficiencia. Pongamos un
ejemplo: si queremos que un usuario extraiga una información de
nuestra base de datos no podemos pasarle la base de datos al usuario
para que el pueda hacer la consulta. Sería demasiado costoso en ancho
de banda, y es probable que no queramos que acceda a toda la
información (ni siquiera que la tenga).
22.. CCGGII ssccrriippttss..
La solución que surge entonces es utilizar un programa que puede
intercambiar datos con el usuario a través de la WWW, ejecutado en
nuestro servidor y que por lo tanto corre en un entorno seguro y que
conocemos. Esos programas podían estar escritos y funcionando en
prácticamente cualquier sistema o lenguaje de programación.
Nuestro script típico tomaría los datos que se le han proporcionado, y
realizaría alguna acción, devolviendo como resultado una página www
que podría ser distinta dependiendo de los datos o del resultado del
proceso en nuestra máquina. Esto significa interactividad con control
en el servidor. Lo único que controla el usuario son los datos que
manda (esto también puede resultar un agujero de seguridad, pero ya
hablaremos de ello más adelante).
Hasta hace relativamente poco, la solución más accesible (y la que
probablemente siga siendo la más adoptada) es usar Perl para procesar
los datos y construir una página que se le pueda devolver al usuario.
Perl es un lenguaje interpretado que posee unas características
particularmente beneficiosas a la hora de escribir programas de este
tipo, ya que fue inicialmente concebido como una herramienta de
proceso de informes y muestra un comportamiento excelente en el
proceso de datos de cualquier tipo. De hecho, PERL es el acrónimo de
_P_r_a_c_t_i_c_a_l _E_x_t_r_a_c_t_i_o_n _a_n_d _R_e_p_o_r_t _L_a_n_g_u_a_g_e, es decir, lenguaje de
programación práctico para extracción y generación de informes.
Además Perl es completamente libre y hay desarrolladas una cantidad
muy importante de librerías de funciones que implementan casi todas
las funciones que uno pueda necesitar. Pero en este punto surgen
varios problemas:
· Cada vez que el script se tiene que ejecutar ha de iniciarse el
intérprete de Perl, lo cual resulta en una sobrecarga inicial no
despreciable. Esto limita nuestro uso del script: sólo podremos
utilizarlo en máquinas potentes o en sistemas que sepamos que van a
tener pocos usuarios simultáneos.
· El script que programemos ha de generar la página íntegramente. Es
decir, que tenemos que programar nuestro script para que el
documento resultante tenga etiquetas como , ,
etc, y en el orden adecuado. Esto tiene repercusiones importantes a
la hora del diseño de webs grandes, en los que el mantenimiento del
estilo y las plantillas no resulta un problema trivial.
22..11.. LLaass aalltteerrnnaattiivvaass..
Como respuesta a estos problemas han surgido varios sistemas, algunos
de ellos dependientes de plataforma, que alivian de algún modo las
pesadillas de los webmasters y de los administradores.
· PHP/ASP. Ahora mismo es el tipo de solución más popular. El
concepto es sencillo: dentro de las propias páginas html se
incluyen unas directivas escritas en un lenguaje especial que se
ejecuta en el servidor (accesos a bases de datos, bucles etc). PHP
por supuesto tiene la ventaja de que es libre y que está disponible
para casi todas las plataformas y sistemas operativos, a diferencia
de las Active Server Pages de Microsoft.
· Servlets. Son programas ejecutados en el lado del servidor que
pueden correr scripts en lenguajes como Java (Java Servlets) aunque
ahora es posible utilizar otros lenguajes interpretados como Python
etc...
22..22.. LLaa ssoolluucciióónn eelleeggiiddaa
Perl Embebido es un módulo de extensión de Perl que nos va a permitir
la máxima interactividad posible desde el servidor usando Perl como
lenguaje de programación.
Perl Embebido supera nuestras dos dificultades principales del
siguiente modo:
· En primer lugar se ejecuta bajo mod_perl (aunque también puede
ejecutarse al estilo de los antiguos CGI's). Mod_perl es un módulo
de Apache que introduce el intérprete de Perl dentro del mismo
servidor Web y que optimiza la ejecución de aplicaciones escritas
en este lenguaje, evitando la sobrecarga de inicialización antes
mencionada y logrando un rendimiento muy superior al de otras
alternativas.
· En segundo lugar y tal como reza el nombre, Perl embebido permite
incluir código Perl directamente dentro de las páginas web. Esto no
sólo resulta cómodo para el programador sino que permite la
integración con otras herramientas que el estilo Perl-CGI antiguo
no nos permitía, como por ejemplo con Website Meta Language.
22..22..11.. PPrriinncciippaalleess vveennttaajjaass ddee PPeerrll EEmmbbeebbiiddoo..
Es conveniente destacar algunas de las principales ventajas a la hora
de utilizar Perl como elemento de acceso a la base de datos, algunas
particulares del lenguaje de programación en sí y otras particulares
de la forma de introducir Perl en servidores WWW:
· Perl es un lenguaje flexible, potente, maduro y muy rápido a la
hora de escribir código.
· Existe una tremenda cantidad de módulos bien documentados que
podemos usar dentro de nuestro código y que nos permiten construir
de forma sencilla aplicaciones web que hagan casi cualquier cosa
(Ej: Acceso a bases de datos independiente de la implementación de
SQL, creación automática de imágenes, operación sobre el sistema
operativo...). Y toda esta funcionalidad se puede explotar con Perl
embebido desde una página Web.
· La ejecución sobre _m_o_d___p_e_r_l es muy veloz. Varias pruebas han
revelado que es muchas veces más rápida que la de CGI's
convencionales.
· Todo el software que es necesario para hacer funcionar _m_o_d___p_e_r_l es
libre y está bien documentado. Además algunas distribuciones lo
incluyen empaquetado y prácticamente listo para usar.
· _m_o_d___p_e_r_l Incluye algunas facilidades propias para manejar aspectos
particulares de la programación web que resultan muy útiles (datos
de formularios, manejo de la sesión, etc).
Quizás la ventaja más importante es que no es necesario aprender un
lenguaje de programación que sirva para una única aplicación. Perl es
multipropósito y tremendamente útil en otros campos de utilización.
22..22..22.. DDeessvveennttaajjaass
Sin embargo Perl embedido no está exento de desventajas, puede
resultar, a priori, un poco más difícil de utilizar que sus rivales.
Además, el lenguaje de programación Perl puede ser bastante difícil de
leer (y por tanto mantener) si no se ha documentado lo suficiente. La
premisa de Perl de poder realizar la misma cosa de muchas maneras
distintas puede llevar a que el mantenimiento del código por parte de
otro programador sea dificultosa si las cosas no se han hecho de
manera ordenada.
33.. PPuueessttaa eenn ffuunncciioonnaammiieennttoo yy ccoonnffiigguurraacciióónn..
Antes de explicar cómo se instala y configura es necesario introducir
los elementos que van a entrar en juego para la instalación.
· Apache: Es el servidor web libre más avanzado y el más usado en
Internet. Implementa un sistema de módulos con los cuales se pueden
añadir funcionalidades al servidor.
· Mod_perl: Es un módulo de Apache que permite la ejecución eficiente
de programas escritos en Perl.
· Perl: Es el intérprete de Perl, con el cual podemos ejecutar
scripts escritos en el lenguaje del mismo nombre.
· DBI: Es un módulo (una biblioteca de funciones) de Perl que nos
permitirá el acceso a bases de datos de forma uniforme e
independiente de la base a la que estemos accediendo (Postgres,
Oracle, Informix, Interbase etc.)
· Postgresql: Es el sistema de base de datos libre más avanzado. La
utilizaremos como ejemplo del acceso a bases de datos desde Perl
Embebido.
· DBD::Pg: Es el módulo que usa DBI para acceder a funciones de
Posgresql, que es la base de datos con la que implementamos
nuestros ejemplos. En caso de utilizar otras bases de datos,
tendremos que utilizar un "driver" distinto (Ej: DBD::Mysql).
44.. IInnssttaallaacciióónn
En primer lugar, para poder hacer nuestras pruebas necesitamos tener
un servidor Apache funcionando. La descripción de la instalación de
Apache queda fuera de la intención de este artículo, pero tampoco es
un tema excesivamente complicado, sobre todo si se usa alguna
distribución como Debian o Red Hat. Para saber si tenemos un servidor
Apache funcionando podemos probar en un navegador cualquiera que esté
en nuestra máquina a acceder a la dirección http://localhost/. Si no
habíamos introducido anteriormente ninguna página y tenemos nuestro
servidor activo, deberíamos ver una página de bienvenida de Apache.
Perl también debe estar instalado en nuestra máquina. Al igual que en
el caso de Apache, existe amplia documentación sobre este proceso, y
la mayoría de las veces es extremadamente sencillo.
Una vez que tenemos estos dos elementos instalados pasamos a la
instalación de _m_o_d___p_e_r_l. Como siempre, si utilizamos una buena
distribución este proceso resultará sencillísimo, tanto como pedirle
al sistema que instale el paquete correspondiente a _m_o_d_-_p_e_r_l (en
Debian se trata del paquete _l_i_b_a_p_a_c_h_e_-_m_o_d_-_p_e_r_l).
Una vez que tenemos el fichero hay que decirle a Apache que lo
utilice. El fichero de configuración de apache "httpd.conf" contiene
los módulos que se cargan al arrancarlo. Lo normal es que este fichero
contenga una linea Loadmodule referente a mod perl, que tan sólo hemos
de descomentar (eliminar el "#" del principio). Si esta línea no
existe, debemos añadirla. La línea tendrá el siguiente aspecto:
LoadModule perl_module /ruta/del/archivo/del/modulo/mod_perl.so
Ahora ya tenemos un servidor con la capacidad de ejecutar scripts a
través de _m_o_d___p_e_r_l. Lo siguiente será hacer que el Perl embebido
funcione. De nuevo aparece la misma disyuntiva: si nuestro Linux está
instalado a partir de una distribución en la cual exista el paquete de
_e_m_b_-_p_e_r_l (en Debian: _l_i_b_h_t_m_l_-_e_m_b_p_e_r_l_-_p_e_r_l) bastará decirle al sistema
que lo instale. Si no, tendremos que bajarnos el archivo de
instalación (ver listado 1) y realizar los siguientes pasos:
perl Makefile.PL
make
make test
make install
El penúltimo de los pasos (make test) requiere que se hallen en su
sistema algunas bibliotecas instaladas de antemano.
Lo último que nos queda por hacer es configurar Apache para que
ciertos tipos de extensiones las procese con Embperl. En principio
nuestro servidor web puede tener gran variedad de tipos de ficheros
que procesar, y no queremos que procese todos a través de Embperl. Por
eso asignaremos a los documentos escritos con este propósito la
extensión de fichero .epl, aunque por supuesto esta configuración
puede (o debe) ser modificada según las necesidades concretas de
nuestro servidor o servicios web.
Para asignar la extensión .epl a los ficheros que deben ser procesados
por Embperl puede bastar con añadir las siguientes líneas a alguno de
los ficheros de configuración de Apache (srm.conf o httpd.conf),
aunque cualquier lector que haya trabajado con este servidor web es,
probablemente, capaz de sugerir varias alternativas.
SetHandler perl-script
PerlHandler HTML::Embperl
Options ExecCGI
AddType text/html .epl
55.. ¿¿CCóómmoo ssee pprrooggrraammaa ccoonn PPeerrll eemmbbeebbiiddoo??
El primer ejemplo que aquí se muestra, servirá para introducir la
sintaxis básica del lenguaje y al mismo tiempo para comprobar que
nuestro sistema está funcionando y procesa nuestros ficheros .epl.
Pero antes necesitamos tener el esqueleto de un archivo escrito en
HTML corriente en el que podamos empotrar nuestro código Perl.
Pruebas de Embperl
Este es nuestro fichero de pruebas
En este fichero todavía no hay nada que tenga que ver con Perl embebido.
El lector que todavía no tenga claro si su servidor web está
funcionando puede comprobarlo copiando este código en un fichero y
poniendo en las localizaciones típicas (pruebe a ponerlo en /var/www/
aunque debería mirar la variable DocumentRoot en su configuración de
Apache).
Ahora comenzaremos a añadir capacidad de proceso a este archivo. En
primer lugar parece bastante lógico que cuando insertemos nuestro Perl
en el html tendremos que separarlo de alguna manera, para que el
intérprete reconozca lo que tiene que procesar y lo que no (el resto
del html). Esto en Perl embebido se hace con corchetes. Una sentencia
típica podría tener el siguiente aspecto.
[- $variable1 = "Hola"; -]
El grupo de caracteres "[-" y "-]" delimitan bloques de código perl
dentro del HTML. Cualquier cosa que esté incluida entre estos símbolos
será interpretada como código Perl. Tan sólo hay que preocuparse de
terminar las sentencias con ";" tal y cómo haríamos en un archivo de
Perl corriente. Lo que hemos hecho en la línea anterior es una simple
asignación, la variable "$variable1" contendrá ahora la cadena de
texto "Hola". Al programador Perl que vea esto lo más probable es que
se le ocurra introducir sentencias con la instrucción "print" dentro
de los delimitadores que acabamos de aprender. Sin embargo, Perl no
sabría dónde tiene que imprimir el resultado de la variable. El
siguiente trozo de código es incorrecto sólo por la declaración en la
que aparece la instrucción _p_r_i_n_t:
[-
$variable1 = "Hola";
$suma = 1 + 2;
if ($suma > 0) {
$texto = "Mayor que cero";
print $texto; # Esta es la línea incorrecta
}
$variable2 = $variable1
-]
Pero entonces ¿cómo imprimimos el resultado de nuestros cálculos (o de
nuestras operaciones interactivas) en la página web? Muy fácil,
usaremos otros delimitadores: "[+" y "+]". El siguiente listado
muestra un ejemplo muy sencillo de cómo podemos imprimir el resultado
de una variable asignada previamente en nuestro código, ya incluido
dentro de nuestra página de prueba:
Pruebas de Embperl
Este es nuestro fichero de pruebas
[- $variable1 = "hola";
$variable2 = ", ¿qué tal?" -]
[+ $variable1 +]
Con este ejemplo, ya podemos comprobar que Embperl está procesando
nuestro fichero. Si nombramos al archivo que contiene el código
anterior "prueba.epl", lo situamos en el mismo lugar donde ya tengamos
páginas funcionando e intentamos acceder a él desde el exterior,
deberíamos ver algo como la figura nº 1.
****** IMAGEN 1 ****************************
En este punto hay que aclarar algunas cuestiones que se pueden
plantear habiendo visto los ejemplos anteriores. En primer lugar, como
ya aparece implícito en los ejemplos anteriores, dentro de los
delimitadores "[-" y "-]" podemos escribir código en varias líneas, e
incluso poner comentarios. El último ";" que pongamos dentro de este
código es opcional, ya que Embperl lo cierra por nosotros en caso de
que no nos demos cuenta.
Podemos incluir cuantos grupos de código queramos, y todos _c_o_m_p_a_r_t_e_n
_e_l _m_i_s_m_o _e_s_p_a_c_i_o _d_e _v_a_r_i_a_b_l_e_s _d_e_n_t_r_o _d_e _u_n_a _m_i_s_m_a _p_á_g_i_n_a _y _u_n_a _m_i_s_m_a
_l_l_a_m_a_d_a. Esto quiere decir por un lado que podemos dotar a las
variables de un valor en un grupo de código y luego usar esa variable
(que ya contiene el valor que le hemos asignado previamente) en otro
grupo, y por otra parte que si un usuario desde Internet decide hacer
una recarga de nuestra página, los valores de las variables no se
conservarán.
Dentro de los delimitadores de impresión en la página ([+ +]) podemos
poner cualquier cosa que pudiera ser argumento de la función print.
Por ejemplo, si queremos que la página descrita unos párrafos más
arriba sea un poco más educada, podemos sustituir la línea "[+
$variable1 +]" por esta otra "[+ "$variable1.$variable2" +]"
Cuando decimos que podemos incluir código dentro de nuestra página,
también quiere decir que puede haber bucles, condiciones y cualquiera
de las posibilidades de control de flujo de un programa que perl nos
brinda (que no son pocas). Pero el verdadero poder que nos brinda Perl
en una página web es la posibilidad de iterar y condicionar no sólo la
ejecución de una parte programada, sino _t_a_m_b_i_é_n _l_a_s _e_t_i_q_u_e_t_a_s _H_T_M_L _y
_s_u_s _c_o_n_t_e_n_i_d_o_s. Para explicar mejor esto, ponemos un ejemplo:
Necesitamos que nuestra página enseñe una imagen si el resultado de un
cálculo anterior es mayor que 5, y en caso contrario, que muestre un
texto de cabecera de primer nivel (). Para hacer esto utilizaremos
lo que se denomina en Embperl _M_e_t_a_-_c_o_m_a_n_d_o_s; aunque el nombre asusta
un poco, tan sólo se trata de separar las sentencias Perl de
bifurcación e iteración en bloques separados. Por ejemplo [$ if
(condición) $] que hay que terminar con [$ endif $]. A continuación
listamos el código que implementa el problema enunciado al principio
del párrafo.
Pruebas de Embperl
Este es nuestro fichero de pruebas
[-
$variable=7; #aquí podría haber algo más complicado.
-]
[$ if ($condicion>5) $]
[$ else $]
La variable es menor o igual a 5, mis disculpas.
[$ endif $]
Desde el punto de vista de la programación Perl choca un poco el hecho
de que haya que cerrar cada una de las sentencias, pero con un poco de
detenimiento podrá el lector observar que si no se le indicara al
intérprete la finalización del bucle o la condición éste no podría
determinar sobre que trozo de código iterar o decidir. Además del
meta-comando que acabamos de utilizar existe uno para cada sentencia
de control de flujo de Perl. A continuación listamos unos cuantos con
sus sentencias de cierre como referencia.
[$ if (condicion) $]
[$ elseif (condicion) $]
...
[$ else $]
[$ endif $]
[$ do $]
[$ until $]
[$ while (condicion) $]
[$ endwhile $]
[$ foreach $var (lista) $]
[$ endforeach $]
Pero el ejemplo descrito anteriormente no resulta de mucha utilidad,
en primer lugar porque siempre producirá la misma salida. Nuestra
próxima tarea será interactuar con el usuario.
La manera más directa y usual para interactuar con el usuario a través
de una página web es un formulario. Embperl nos permite acceder
fácilmente a la información proveniente de los formularios que se ha
enviado a nuestra pagina-Embperl_script. Para eso existe una
estructura de tipo "hash" (tambien llamada array asociativo) con la
cual podemos acceder directamente a estos datos. Este "hash" se llama
%fdat contiene la información enviada de la siguiente forma:
%fdat = (
nombre_del_campo => información_del_campo,
nombre_otro_campo => información_del_otro_campo
)
Para verlo más claro supongamos que una página web que hemos hecho de
antemano (que no tiene porqué tener nada que ver con Embperl) contiene
las siguientes líneas:
Cuando el usuario de esta página pulsa el botón en el que pone
"enviar", el navegador envía una petición http de la página-script
"prueba.epl" (la que ahora nos ocupa) incluyendo la información del
formulario que hemos descrito un poco antes. Para saber si el usuario
que lo ha mandado ha tecleado en el campo de nombre la información
"pepe", y obrar en consecuencia, podríamos incluir en nuestra página
el siguiente código:
[$ if ($fdat{nombre} eq "Pepe") $]
[+ "¡Qué alegría Pepe, cuanto tiempo sin saber nada de tí!" +]
[$ else $]
Lo siento, [+ $fdat{nombre} +], pero no nos han presentado.
[$ endif $]
Ahora tenemos una visión más amplia de lo que puede hacer Embperl por
la interactividad de nuestras páginas. Pero todavía no hemos abierto
la caja de Pandora, o mejor dicho CPAN, el archivo de módulos Perl.
66.. PPrrooggrraammaacciióónn eenn PPeerrll::::DDBBII
DBI es el acrónimo de _D_a_t_a_b_a_s_e _I_n_t_e_r_f_a_c_e, y es un módulo que permite
al programa abstraerse de la implementación específica del acceso a la
base de datos, que puede ser distinta en cada base de datos, y le
permite programar el acceso a una base de datos de manera
transparente. De esta forma se está facilitando la portabilidad de los
diversos programas ya que no están "atados" a ninguna base de datos.
Como se muestra en la figura 2, Perl::DBI encaja entre los programas y
los interfaces particulares de cada base de datos, los llamados DBD
(de _D_a_t_a_b_a_s_e _D_r_i_v_e_r_s) que son los que implementan el acceso a la base
de datos en sí.
DBI tiene un interfaz muy sencillo que permitirá al programador
seleccionar la base de datos a utilizar y hacer consultas SQL,
devolviendo los resultados en tablas o arrays asociativos que puedan
ser fácilmente tratados en Perl.
El acceso a una base de datos con Perl::DBI se limita a:
· La conexión a la base de datos, que se realiza con la función
_c_o_n_n_e_c_t y en la que se indica la base de datos a utilizar, así como
el usuario y contraseña para realizar la conexión.
· La preparación de una llamada SQL con la función _p_r_e_p_a_r_e, que se
utilizará para que el motor de la base de datos con la que se ha
realizado la conexión "compile" la instrucción SQL y se prepare a
ejecutarla.
· La ejecución de la llamada SQL ya preparada con la función _e_x_e_c_u_t_e.
· La recuperación de los datos resultados de la ejecución de la orden
SQL con las funciones _f_e_t_c_h_r_o_w___a_r_r_a_y, _f_e_t_c_h_r_o_w___a_r_r_a_y_r_e_f o
_f_e_t_c_h_r_o_w___h_a_s_h_r_e_f.
· La finalización de la consulta con la función _f_i_n_i_s_h.
· La desconexión de la base de datos con la orden _d_i_s_c_o_n_n_e_c_t.
77.. MMiiggrraacciióónn ddee ppggssqqll aa PPeerrll EEmmbbeeddiiddoo
En los artículos anteriores se ha desarrollado el acceso a una base de
datos utilizando un preprocesador específico para PostgreSQL que
permitía desarrollar intérpretes CGI rápidamente con los que acceder a
la base de datos. Sin embargo este acercamiento no esta exento de
problemas, algunos de los cuales ya se introdujeron en artículos
previos, y que pueden concretarse en:
· dificultada en la intercepción de errores.
· dificultad en la comprobación de datos recibidos.
· dificultad en la elaboración de interfaces complejos.
· necesidad de la separación de los formularios y el acceso a la base
de datos.
Estos problemas van a poder ser solventados, pero no sin antes un
esfuerzo adicional de programación para contemplarlos y una
reimplementación haciendo uso de Perl embedido. Una vez hecha, sin
embargo, la reimplementación, la disponibilidad de un gran número de
módulos de Perl para las más diversas tareas (envío de correos
electrónicos, acceso a ficheros...) así como la integración con el
servidor de Apache para la gestión, por ejemplo, de cookies o de
sesiones, nos permitirán poder abrir nuevos campos de aplicación al
interfaz ya realizado.
Otra ventaja, además, es que podremos coger consultas implementadas en
Perl embedido y, con mínimos esfuerzo, convertirlas en programas
interpretados escritos en Perl que se ejecuten en el servidor. Esto va
a permitir, si fuera necesario, convertir el tratamiento dinámico de
la información en estático, si fuera necesario.
77..11.. CCoonnssuullttaa ddee ddaattooss ccoonn PPeerrll eemmbbeeddiiddoo
************** LISTADO 2 ****************************+
Como se puede ver en el listado 2, el acceso a las funciones de Perl
embedido permiten programa muchas características dentro de una
página. Vamos a tomar dicho listado como la base de un ejemplo para
ver cómo se haría la migración de las distintas consultas y
formularios de introducción de datos en este lenguaje, analizándolo
por completo.
En primer lugar se puede ver que el primer bloque hace que se carguen
los distintos módulos que van a ser utilizados por el intérprete, de
particular interés serán DBI, ya comentado, y CGI::Cookie, que
permitirá acceder a las cookies que el usuario envíe al servidor.
Estas cookies, como ya se comentó en artículos anteriores son las que
se van a utilizar para identificar si el usuario ha sido autenticado.
Posteriormente, se hace la conexión con la base de datos, utilizando
la función correspondiente del módulo DBI, preservando en variables la
posibilidad o no de haber realizado la conexión. Esto va a permitir
que, a continuación se puedan tratar los casos de fallo de conexión a
la base de datos.
Como se puede ver en el bloque _i_f se pueden, dentro de una misma
página introducir información que se va a mostrar en función de las
acciones tomadas anteriormente. Este bloque permite mostrar una página
determinada (en realidad va a reenviar al usuario con un _r_e_f_r_e_s_h a la
página en cuestión) en el caso de que no se haya podido establecer la
conexión a la base de datos. Los siguientes bloques se evaluarán sólo
en el caso de que la conexión haya sido exitosa, ya que, de no serlo,
el intérprete saltará al bloque _e_n_d_i_f correspondiente.
A continuación se evalúa si la _c_o_o_k_i_e del usuario corresponde con una
válida, utilizando el valor de ésta para realizar una consulta a la
base de datos que nos indicará si está accediendo un usuario
autorizado.
En el caso de que no lo sea, hay un nuevo error que le indicará al
usuario que no pertenece a la base de datos y deberá autenticarse. Si
lo es, se llegará a la construcción de la consulta que será realizada
en la base de datos, en este caso un listado de Antiguos Alumnos.
Se utiliza Perl embedido para procesar la consulta a través del
interfaz DBI, y para mostrar la lista de columnas recibidas dentro de
una tabla. En el caso de que no haya datos se muestra un mensaje
explicativo indicando la razón.
Asimismo se pueden introducir en una misma página tres páginas
distintas que serán mostradas en función de las condiciones de
ejecución del programa.
77..22.. AAuutteennttiiccaacciióónn ddee uussuuaarriiooss ccoonn PPeerrll eemmbbeeddiiddoo
************** LISTADO 3 ***************************
Finalmente, como ejemplo más complejo se puede consultar el listado 3.
Éste sería el correspondiente a la página de acceso al servidor, que,
como se puede ver es dinámica.
En dicha página está incluido el formulario de entrada de datos del
usuario, la comprobación de los datos en sí, y los mensajes de
aceptación y rechazo correspondientes. Como se puede ver se puede
hacer de golpe todas estas operaciones sin tener que necesitar
distintas páginas separadas que sí eran necesarias en el caso de
pgsql.
Se deja, por limitaciones de espacion, como ejercicio al lector el
determinar el exacto funcionamiento de este programa.
88.. RReessuummeenn
Como se ha visto en éste artículo es posible hacer uso de toda la
potencia expresiva de Perl en la programación de páginas dentro de
servidores de WWW, esto, acompañado con la gran versatilidad del
módulo Perl::DBI permite a los programadores la definición de
interfaces desde WWW a servidores de bases de datos que sean
fácilmente portables entre servidores, sistemas operativos y sistemas
de gestión de bases de datos.
99.. SSuummaarriiooss
La solución más fácil para hacer CGIs es usar Perl.
Perl posee beneficiosas características a la hora de escribir
programas.
Existen alternativas al uso de Perl embedido.
Perl emebedido permite una gran interactividad en el servidor.
Antes de nada es necesario introducir los elementos necesarios.
La configuración para Perl embedido no es complicada.
No es difícil introducir Perl embedido en páginas HTML.
DBI es un interfaz genérico de acceso a bases de datos.
Se reimplementarán los ejemplos anteriores con Perl embedido.
Es posible hacer uso de toda la potencia expresiva de Perl.
1100.. LLiissttaaddooss
LISTADO 1
Algunos servidores de interés son:
· www.apache.org que contiene toda la información relativa al
servidor Apache.
· www.perl.org, toda la información sobre el lenguaje de programación
Perl.
· perl.apache.org, que contiene toda la información sobre la
integración de Perl y Apache.
· www.cpan.org, servidor que ofrece todos los módulos disponibles
para Perl.
· www.postgresql.org, el servidor principal del sistema de gestión de
bases de datos PostgreSQL.
· Se puede encontrar gran información sobre DBI en la página de
recursos http://www.symbolstone.org/technology/perl/DBI/
· El proyecto WebDBI, www.wdbi.net, es también de gran interés en el
sentido de que permite realizar rápidamente interfaces web a bases
de datos con DBI y perl embedido. Merece la pena conocerlo.
· lucas.hispalinux.es, que contiene gran cantidad de documentación
traducida al castellano incluyendo el proyecto de traducción de
PostgreSQL al castellano. Otro servidor de gran interés para
hispano parlantes es www.postgres.org.mx
El libro de O'reilly de Perl::DBI "Programming the Perl DBI" de
Alligator Descartes y Tim Bunce, los creadores del módulo es una
estupenda referencia sobre el tema (ISBN: 1565926994).
PIE LISTADO 1: Más información
LISTADO 2
Listado de antiguos alumnos por año de promoción
[-
use DBI;
use POSIX qw/strftime/;
use CGI::Cookie;
%cookies = fetch CGI::Cookie;
$db="alumni2k";
$uslec="lectura";
-]
[-
$dbuser=$uslec;
if (not(defined($dbhlectura))) {
eval {$dbhlectura = DBI->connect("dbi:Pg:dbname=$db", "$dbuser", "")
or die "No puedo abrir la base de datos $dbname con el usuario $dbuser\n"; };
$falloconex = "fallo" if ( ! defined($dbhlectura) );
};
-]
[$ if ($falloconex) $]
[- $udat{errores}="Sin conexión"; -]
Ha habido un error%lt;/A>
[$ else $]
[- if (exists($cookies{'codigo'}) && $cookies{'codigo'}->value != 0 )
{
$codigo = $cookies{'codigo'}->value;
@arraydatos = $dbhlectura->selectrow_array("SELECT DISTINCT codigo, nombre, apellido, id_persona FROM persona WHERE codigo = \'$codigo\'");
}
if (@arraydatos)
{
$ref = \@arraydatos;
($bogus,$nombreusuario,$apellidousuario,$idpersona)=@$ref;
}
else {$ref=""}
-]
[$ if (not($ref)) $]
[- $udat{errores}="No es miembro o no autentificado"; -]
Ha habido algún error en el proceso, si su navegador no se lo muestra
automáticamente pulse aquí.
[$ else $]
Listado de AAs por año de promoción
[-
$consulta = "select nombre, apellido, graduacion from persona, datos_academicos where persona.id_persona = datos_academicos.id_persona and autorizacion = 1 order by graduacion";
$sth = $dbhlectura->prepare($consulta);
$sth->execute or die "Lo siento, no puedo realizar la consulta en este momento";
$head = $sth->{NAME};
$data = $sth->fetchall_arrayref ;
$rows = $sth->rows;
-]
[$ if $rows > 0 $]
| [+ $head->[$col] +] |
|---|
| [+ $data -> [$row][$col] +] |
[$ else $]
Lo lamentamos, pero no hay datos en la base de datos en respuesta
a la consulta