Archivo de la categoría: PostgreSQL

Articulos relacionados con la puesta a punto de la base de datos PostgreSQL.

Compilar PostgreSQL 9.2.4 con soporte para pldebugger en Debian 6

Logo PostgreSQLRecientemente en el trabajo, he tenido que desarrollar un triger para PostgresSQL algo complejo, así que la posibilidad de depurarlo paso a paso era muy desaeable. Sin embargo al intentar acceder al depurador desde pgAdminIII, resulta que la mayoría de las versiones de PostgreSQL para linux no disponen de esta funcionalidad.

Así pues, la única solución es compilar el plugin pldebugger desde las fuentes y añadirlo a PostgresSQL.

Sin embargo, para compilar este plugin es necesario disponer del código fuente de PostgreSQL, así que.. una vez metidos en faena… ¿porque que no aprovechar para instalar desde las fuentes la base de datos también?

Las versiones del software que se usaran en el articulo son las siguientes:

  •           Debian 6.1
  •           PostgreSQL 9.2.4
  •           pldebugger

Para lograr nuestro objetivo, y partiendo de una instalación limpia de Debian 6 NetInstall seguiremos los siguientes pasos:

1.- Instalar los paquetes build-esentials

Lo primero que debemos hacer es instalar los paquetes esenciales para poder compilar en nuestra distribución. En el caso de Debian 6, deberemos ejecutar la siguiente instrucción:

[sourcecode language=»text» gutter=»false» wraplines=»false» highlight=»1″]
# apt-get install build-essential
[/sourcecode]

Además debemos bajarnos algunas bibliotecas extra que necesitaremos para realizar la compilación de PostgreSQL con éxito:

[sourcecode language=»text» gutter=»false» wraplines=»false» highlight=»1″]
# apt-get install libreadline5 libreadline5-dev zlib1g zlib1g-dev openssl libssl-dev
[/sourcecode]

Las bibliotecas instaladas y su propósito son las siguientes:

También necesitaremos el cliente Git para poder descargar directamente del repositorio de pldebugger los fuentes del plugin:

[sourcecode language=»text» gutter=»false» wraplines=»false» highlight=»1″]
# apt-get install git
[/sourcecode]

2.- Obtener el código fuente de PostgreSQL

El siguiente paso es obtener el código fuente de PostgreSQL, para lo cual usaremos el comando wget:

[sourcecode language=»text» gutter=»false» wraplines=»false» highlight=»1″]
# wget http://ftp.postgresql.org/pub/source/v9.2.4/postgresql-9.2.4.tar.gz
[/sourcecode]

A continuación descomprimimos el fichero tar.gz que nos hemos descargado con la instrucción:

[sourcecode language=»text» gutter=»false» wraplines=»false» highlight=»1″]
# tar xvzf ./postgresql-9.2.4.tar.gz
[/sourcecode]


3.- Obtener el código fuente del plugin pldebugger

Obtendremos el código fuente del plugin pldebugger desde los repositorios del proyecto con el comando git:

[sourcecode language=»text» gutter=»false» wraplines=»false» highlight=»1″]
# git clone git://git.postgresql.org/git/pldebugger.git
[/sourcecode]

Siguiendo las instrucciones de instalación del plugin, copiamos el directorio que acabamos de descargar al directorio /comtrib del arbol de directorios del código fuente de PostgresSQL:

[sourcecode language=»text» gutter=»false» wraplines=»false» highlight=»1″]
# cp ./pldebugger/ ./postgresql-9.2.4/contrib/ -R
[/sourcecode]

4.- Establecer las opciones de compilación de PostgresSQL

El siguiente paso es establecer las opciones de compilación. Para ello entraremos en el directorio donde están las fuentes de PostgreSQL:

[sourcecode language=»text» gutter=»false» wraplines=»false» highlight=»1″]
# cd ./postgresql-9.2.4
[/sourcecode]

y escribiremos el siguiente comando:

[sourcecode language=»text» gutter=»false» wraplines=»false» highlight=»1″]
# ./configure -with-openssl -enable-thread-safety
[/sourcecode]

Las opciones de configuración establecidas son las siguientes:

  • -with-openssl: Permite conexiones encriptadas medieante SSL
  • -enable-thread-safety: Permite el uso seguro de concurrencia (hebras)


5.- Compliar el código fuente PostgreSQL

Una vez establecidas las opciones de configuración sin errores, procedemos a compilar el código fuente de PostgresSQL, para lo cual bastara llamar al comando make:

[sourcecode language=»text» gutter=»false» wraplines=»false» highlight=»1″]
# make
[/sourcecode]

6.- Instalar los binarios

Si la compilación se ha completado sin errores, procederemos a instalar los binarios de la aplicación:

[sourcecode language=»text» gutter=»false» wraplines=»false» highlight=»1″]
# make install
[/sourcecode]

Con ello ya tenemos instalado PostgreSQL en nuestra máquina.

7.- Compilar pldebugger

Para continuar , debemos compilar el pluging pldebugger. Para ello debemos ingresar en el directorio dentro del árbol de fuentes de PostgreSQL donde copiamos el código fuente del pluging. Si hemos seguido al pie de la letra las instrucciones de este articulo, deberíamos estar en el directorio ./postgresql-9.2.4, por lo que continuaremos ejecutando los siguientes comandos:

[sourcecode language=»text» gutter=»false» wraplines=»false» highlight=»1″]
# cd ./contrib/pldebugger/
[/sourcecode]

y compilamos el plugin.

[sourcecode language=»text» gutter=»false» wraplines=»false» highlight=»1″]
# make
[/sourcecode]


8.- Instalar pldebugger

Instalar el plugin es tan sencillo como ejecutar el siguiente comando:

[sourcecode language=»text» gutter=»false» wraplines=»false» highlight=»1″]
# make install
[/sourcecode]

9.- Configurar postgreSQL

9.1 Añadir binarios al path del sistema

El siguiente paso es editar el fichero de configuración de bash /etc/profile para añadir la ruta de los binarios de PostgresSQL a la variable PATH del sistema.Para ello añadiremos al fichero la línea:

[sourcecode language=»text» gutter=»false» wraplines=»false»]
PATH="/usr/local/pgsql/bin":$PATH
[/sourcecode]

dejándolo de forma parecida a este:

[sourcecode language=»text» gutter=»true» wraplines=»false» highlight=»9″]
# /etc/profile: system-wide .profile file for the Bourne shell (sh(1))
# and Bourne compatible shells (bash(1), ksh(1), ash(1), …).

if [ "`id -u`" -eq 0 ]; then
PATH="/usr/local/sbin:/usr/local/bin:/usr/sbin:/usr/bin:/sbin:/bin"
else
PATH="/usr/local/bin:/usr/bin:/bin:/usr/local/games:/usr/games"
fi
PATH="/usr/local/pgsql/bin":$PATH
export PATH

if [ "$PS1" ]; then
if [ "$BASH" ]; then
# The file bash.bashrc already sets the default PS1.
# PS1=’\h:\w\$ ‘
if [ -f /etc/bash.bashrc ]; then
. /etc/bash.bashrc
fi
else
if [ "`id -u`" -eq 0 ]; then
PS1=’# ‘
else
PS1=’$ ‘
fi
fi
fi

# The default umask is now handled by pam_umask.
# See pam_umask(8) and /etc/login.defs.

if [ -d /etc/profile.d ]; then
for i in /etc/profile.d/*.sh; do
if [ -r $i ]; then
. $i
fi
done
unset i
fi
[/sourcecode]

Si todo ha ido bien, al cerrar sesión y volver a entrar con nuestro usuario, el comando :

[sourcecode language=»text» gutter=»false» wraplines=»false» highlight=»1″]
# echo $PATH
[/sourcecode]

nos debe retornar algo parecido a esto:

[sourcecode language=»text» gutter=»false» wraplines=»false»]
/usr/local/pgsql/bin:/usr/local/sbin:/usr/local/bin:/usr/sbin:/usr/bin:/sbin:/bin
[/sourcecode]

donde vemos que en primer lugar esta incluida la ruta a los binarios de PostgresSQL.

9.2 Crear el usuario postgres

A continuación creamos el usuario postgres<+/em> que será el usuario bajo el cual se ejecute la base de datos:

[sourcecode language=»text» gutter=»false» wraplines=»false» highlight=»1″]
# adduser postgres
[/sourcecode]

Cuando se nos pregunte la contraseña le podremos la que deseemos, pero deberemos recordarla, ya que se nos pedirá en un futuro.

9.3 Crear e inicializar el directorio de datos

El siguiente paso será crear e inicializar el directorio de datos, donde PostgreSQL guardará la información:

[sourcecode language=»text» gutter=»false» wraplines=»false» highlight=»1″]
# mkdir /usr/local/pgsql/data
[/sourcecode]

Hacemos propietario de este directorio al usuario postgres:

[sourcecode language=»text» gutter=»false» wraplines=»false» highlight=»1″]
# chown postgres /usr/local/pgsql/data
[/sourcecode]

A continuación asumimos la identidad del usuario postgres para inicializar el directorio de datos:

[sourcecode language=»text» gutter=»false» wraplines=»false» highlight=»1″]
# su – postgres
[/sourcecode]

y finalmente inicializamos el directorio de datos:

[sourcecode language=»text» gutter=»false» wraplines=»false» highlight=»1″]
$ initdb -D /usr/local/pgsql/data
[/sourcecode]

Llegados a este punto, y si todo ha ido bien, el deberemos ver en nuestra terminal algo parecido a esto

[sourcecode language=»text» gutter=»false» wraplines=»false»]
Success. You can now start the database server using:

postgres -D /usr/local/pgsql/data
or
pg_ctl -D /usr/local/pgsql/data -l logfile start

[/sourcecode]

En este momento, tal y como indica el sistema podremos arrancar la base de datos en primer plano con:

[sourcecode language=»text» gutter=»false» wraplinec=»false» highlight=»1″]
# postgres -D /usr/local/pgsql/data
[/sourcecode]

y detenerla simplemente pulsando la combinación de teclas Ctr-C

Si deseamos arrancar la base de datos en segundo plano, lo haremos usando la segunda opción:

[sourcecode language=»text» gutter=»false» wraplines=»false» highlight=»1″]
# pg_ctl -D /usr/local/pgsql/data -l logfile start
[/sourcecode]

y la detendremos con el siguiente comando:

[sourcecode language=»text» gutter=»false» wraplines=»false» highlight=»1″]
$ pg_ctl -D /var/pgsql/data stop -m fast
[/sourcecode]

9.4 Configurar contraseña de acceso a la base de datos para el usuario postgres

Para configurar la contraseña de acceso del usuario postgres a la base de datos, lo primero que habrá que hacer lógicamente es iniciar el servidor:

[sourcecode language=»text» gutter=»false» wraplines=»false» highlight=»1″]
# pg_ctl -D /usr/local/pgsql/data -l logfile start
[/sourcecode]

Una vez iniciado el servidor, y manteniendo en el sistema la identidad del usuario postgres, accederemos al interprete de ordenes de PostgreSQL:

[sourcecode language=»text» gutter=»false» wraplines=»false» highlight=»1″]
$psql
[/sourcecode]

Una vez dentro, escribiremos:

[sourcecode language=»sql» gutter=»false» wraplines=»false»]
postgres=# alter user postgres with password ‘passwd’;
[/sourcecode]

donde passwd es la nueva contraseña que deseamos poner.El sistema debe responder con un:

[sourcecode language=»sql» gutter=»false» wraplines=»false»]
ALTER ROLE
postgres=#
[/sourcecode]

Salimos del cliente de linea de ordenes con la orden:

[sourcecode language=»text» gutter=»false» wraplines=»false»]postgres=#\q [/sourcecode]

Y salimos de la cuenta en el sistema del usuario postgres con un simple:

[sourcecode language=»text» gutter=»false» wraplines=»false» highlight=»1″]$exit [/sourcecode]


9.5 Crear script de arranque automático

Para hacer que PostgreSQL se ejecute automáticamente al iniciar el sistema, debemos copiar desde el directorio /contrib/start-scripts del arbol del código fuente de postgreSQL, el fichero denominado linux al directorio /etc/init.d. En este punto de la instalación, deberíamos estar en el directorio ./postgresql-9.2.4/contrib/pldebugger, por lo que ejecutaremos el siguiente comando:

[sourcecode language=»text» gutter=»false» wraplines=»false» highlight=»1″]
# cp ../start-scripts/linux /etc/init.d/postgresql
[/sourcecode]

Una vez copiado el script, debemos editarlo para añadirle las etiquetas LSB. Para ello, añadiremos al comienzo del fichero /etc/init.d/posgresql, justo debajo de #! /bin/sh las siguientes líneas:

[sourcecode language=»text» gutter=»true» wraplines=»false» firstline=»2″]
### BEGIN INIT INFO
# Provides: PostgreSQL
# Required-Start: $remote_fs $syslog
# Required-Stop: $remote_fs $syslog
# Default-Start: 2 3 4 5
# Default-Stop: 0 1 6
# Short-Description: Start Postgresql at boot time
# Description: Enable service provided by daemon.
### END INIT INFO
[/sourcecode]

Además, debemos dar permisos de ejecución al script, con el siguiente comando:

[sourcecode language=»text» gutter=»false» wraplines=»false» highlight=»1″]
# chmod 755 /etc/init.d/postgresql
[/sourcecode]

Con ello, podremos arrancar y parar postgresql con el tipico comando:

[sourcecode language=»text» gutter=»false» wraplines=»false» highlight=»1″]
# /etc/init.d/postgresql accion
[/sourcecode]

donde accion representa alguna de las siguientes posibles acciones:

  • start Arranca el servidor de bases de datos.
  • stop Detiene el servidor de bases de datos.
  • restart Detiene el servidor de bases de datos, y lo vuelve a arrancar.
  • reload Recarga la configuración del servidor de bases de datos.
  • status Informa si el servidor de bases de datos se esta ejecutando o no.

Por último, debemos añadir el script de inicio de PostgreSQL a los scripts de arranque del sistema, para lo cual ejecutaremos el siguiente comando:

[sourcecode language=»text» gutter=»false» wraplines=»false» highlight=»1″]
# update-rc.d postgresql defaults
[/sourcecode]

Si por alguna razón deseamos eliminar el script de la secuencia de arranque, deberemos ejecutar el comando:

[sourcecode language=»text» gutter=»false» wraplines=»false» highlight=»1″]
# update-rc.d -f postgresql remove
[/sourcecode]


9.6 Editar el fichero postgresql.conf

El siguiente paso es editar el fichero /usr/local/pgsql/data/postgresql.conf para, por un lado permitir que el servidor escuche por todas las interfaces de red, y por otro lado, indicarle que cargue el plugin pldebugger.

Para permitir que el servidor escuche por todas las interfaces de red, buscaremos la línea:

[sourcecode language=»text» gutter=»true» wraplines=»false» firstline=»59″]#listen-addresses = ‘localhost’ [/sourcecode]

(suele ser la línea 59), la copiamos debajo, la descomentamos, y la modificamos quedando :

[sourcecode language=»text» gutter=»true» wraplines=»false» firstline=»60″]listen-addresses = ‘*’ [/sourcecode]

Si se quisera que PostgreSQL escuchase sólo las peticiones de determinadas IPs, bastaría con poner estas IPs separadas por comas, y todo el conjunto entre comillas simples. Por ejemplo:

[sourcecode language=»text» gutter=»true» wraplines=»false» firstline=»60″]
listen-addresses = ‘192.168.0.2,192.168.0.3’
[/sourcecode]

Nota: por custiones de seguridad no se recomienda permitir el acceso desde cualquier máquina.

Para indicarle a PostgreSQL que cargue el plugin pldebugger al arrancar, buscaremos la línea:

[sourcecode language=»text» gutter=»true» wraplines=»false» firstline=»127″]
#shared_preload_libraries = » # (change requires restart)
[/sourcecode]

(suele ser la línea 127), la copiamos debajo, la descomentamos, y la modificamos quedando :

[sourcecode language=»text» gutter=»true» wraplines=»false» firstline=»128″]
shared_pbeload_libraries = ‘$libdir/plugin_debugger’ # (change requires restart)
[/sourcecode]

9.7 Configurar permisos de acceso

9.7.1 Configurar permisos de acceso local:

Al compilar desde las fuentes, PostgreSQL es muy poco restrictivo a la hora de gestionar permisos, ya que por defecto, permite a todos los usuarios del sistema el acceso sin contraseña. Por ello deberemos restringir ciertos permisos locales.

Para ello debemos editar el fichero /usr/local/pgsql/data/pg_hba.conf
Buscaremos la línea cuyo contenido es:

[sourcecode language=»text» gutter=»true» wraplines=»false» firstline=»84″]local all all trust[/sourcecode]

y la modificamos de forma que quede:

[sourcecode language=»text» gutter=»true» wraplines=»false» firstline=»84″]local all all md5[/sourcecode]

Con ello permitimos el acceso a cualquier cuenta de usuario desde la maquina local siempre que se especifique una contraseña encriptada mediante md5. Ello implica que al reinicar el servidor podremos acceder al cliente de linea de ordenes de PostgreSQL desde cualquier cuenta de usuario con la cuenta de postgres, escribiendo:

[sourcecode language=»text» gutter=»false» wraplines=»false»]$psql -U postgres -W [/sourcecode]

9.7.2 Configurar permisos de acceso remoto:

Por último, debemos configurar los permisos de acceso remoto. Se trata de responder a las siguientes preguntas:

  • ¿Que usuarios tienen permisos para conectarse?
  • ¿Desde que IPs se pueden conectar?
  • ¿A que bases de datos?
  • ¿Y.. que método de auteticación tienen que usar?

En este post, daremos permisos a todos los usuarios de la base de datos, para conectarse a todas las bases de datos, desde cualquier IP, usando una contraseña encriptada con MD5.

Esto lo lograremos editando de nuevo el fichero /usr/local/pgsql/data/pg_hba.conf y localizando la línea:

[sourcecode language=»text» gutter=»true» wraplines=»false» firstline=»86″]
host all all 127.0.0.1/32 trust
[/sourcecode]

y la modificandola forma que quede:

[sourcecode language=»text» gutter=»true» wraplines=»false» firstline=»86″]
host all all 0.0.0.0 0.0.0.0 md5
[/sourcecode]

Una explicación sencilla de esta regla de permisos del fichero /etc/postgresql/9.2/main/pg_hba.conf seria:

  • host: Indica que la regla se refiere a conexiones remotas
  • all: Responde a la pregunta ¿Que usuarios tienen permiso para conectarse?. En este caso todos.Si quisieramos especificar un usuario determinado, bastaría con sustituir «all» por el nombre del usuario deseado. Si queremos aplicar la misma regla a varios usuarios, tendremos que copiar y pegar la regla, cambiando el nombre de usuario.
  • all: Responde a la pregunta ¿A que bases de datos?. En este caso a todas .Si quisieramos especificar una base de datos determinada, bastaría con sustituir «all» por el nombre de la base de datos deseada. Si queremos aplicar la misma regla a varios bases de datos, tendremos que copiar y pegar la regla, cambiando el nombre de la base de datos.
  • 0.0.0.0 0.0.0.0: Responde a la pregunta ¿Desde que IPs se pueden conectar?. En este caso desde todas. el primer grupo de 4 digitos especifca la IP, mientras que el segundo es la mascara de red. Los valores 0.0.0.0 son valores comodin, cuyo significado es «cualquier IP» y «cualquier mascara» respectivamente.
  • md5: Responde a la pregunta ¿Que método de auteticación tienen que usar?. En este caso una contraseña encriptada con MD5. Otros posibles valores son : «passowrd» para una contraseña sin encriptar o «trust» para permitir un acceso sin contraseña

Para una mayor información sobre como funciona el fichero /etc/postgresql/9.2/main/pg_hba.conf se puede consultar la documentación oficial en castellano en la dirección: http://www.postgresql.org/docs/9.2/interactive/auth-pg-hba-conf.html

Finalmente inhabilitaremos las conexiones locales a través de IP6, para lo cual, localizaremos la línea:

[sourcecode language=»text» gutter=»true» wraplines=»false» firstline=»88″]
host all all ::1/128 trust
[/sourcecode]

y la comentaremos de forma que quede:

[sourcecode language=»text» gutter=»true» wraplines=»false» firstline=»88″]
#host all all ::1/128 trust
[/sourcecode]


10.- Reiniciar el servidor

Para comprobar que todo ha ido bien, que el script de autoarranque esta correctamente instalado, y que las configuraciones definidas en la base de datos son correctas, Debemos reiniciar la máquina servidora. Para ello, ejecutaremos las siguiente instrucción:

[sourcecode language=»text» gutter=»false» wraplines=»false» highline=»1″]
# reboot
[/sourcecode]

11.- Probar el depurador

Para probar el depuraror, lo primero que hemos de hacer es crear una base de datos de prueba,con una tabla de prueba, y con un procedimiento almacenado de prueba que podamos depurar.

11.1.- Acceder al interprete de PostgreSQL

Accedemos al interprete de comandos de PostgresSQL con la siguiente instrucción:

[sourcecode language=»text» gutter=»false» wraplines=»false» highline=»1″]
$ psql -U postgres -W
[/sourcecode]

11.2.- Crear base de datos de prueba

Una vez dentro del interprete de comandos de PostgresSQL creamos la base de datos con el siguiente comando:

[sourcecode language=»sql» gutter=»false» wraplines=»false»]
postgres=# CREATE DATABASE prueba_debugger WITH ENCODING=’UTF8′;
[/sourcecode]

11.3.- Crear tabla de pruebas

Nos conectamos a la base de datos que acabamos de crear:

[sourcecode language=»sql» gutter=»false» wraplines=»false»]
postgres=# \c prueba_debugger
[/sourcecode]

y el sistema responde con:

[sourcecode language=»sql» gutter=»false» wraplines=»false»]
You are now connected to database "prueba_debugger".
[/sourcecode]

A continuación creamos la la tabla de pruebas

[sourcecode language=»sql» gutter=»false» wraplines=»false»]
prueba_debugger=# CREATE TABLE tabla_prueba (
Id BIGSERIAL PRIMARY KEY ,
Valor VARCHAR (255) default »
);
[/sourcecode]

y el sistema responde con:

[sourcecode language=»sql» gutter=»false» wraplines=»false»]
NOTICE: CREATE TABLE will create implicit sequence "tabla_prueba_id_seq" for serial column "tabla_prueba.id"
NOTICE: CREATE TABLE / PRIMARY KEY will create implicit index "tabla_prueba_pkey" for table "tabla_prueba"
CREATE TABLE
[/sourcecode]

11.4.- Crear procedimiento almacenado de prueba

Seguimos creando objetos en la base de datos de prueba. En este punto crearemos un procedimiento almacenado:

+

[sourcecode language=»sql» gutter=»false» wraplines=»false»]
prueba_debugger=#
CREATE OR REPLACE FUNCTION tabla_prueba_trigger() RETURNS TRIGGER AS $tabla_prueba_trigger$
DECLARE
sValor VARCHAR (255):= NEW.Valor;
iId INTEGER:= NEW.Id;
iCalculo INTEGER:= 0;
BEGIN
RAISE NOTICE ‘———- INICIO prueba_debugger.tabla_prueba_trigger() ———-‘;
RAISE NOTICE ‘———- => El nuevo registro tiene un Id: %’,iId;
RAISE NOTICE ‘———- => El nuevo registro tiene un Valor: %’,sValor;
iCalculo=iId +5;
RAISE NOTICE ‘———- => El Id del nuevo registro +5 es igual a: %’,iCalculo;
RAISE NOTICE ‘———- FIN prueba_debugger.tabla_prueba_trigger() ————-‘;
NEW.Id= iCalculo;
RETURN NEW;
END;
[/sourcecode]

Nota: para introducir el procedimiento almacenado desde la consola de PostgreSQL copiaremos todo el procedimiento almacenado y pulsaremos la tecla Enter.
A continuación le indicamos a PostgreSQL el lenguaje en el que está escrito el procedimiento almacenado:

[sourcecode language=»sql» gutter=»false» wraplines=»false»]
prueba_debugger=# $tabla_prueba_trigger$ LANGUAGE plpgsql;
[/sourcecode]

Despues de introducir el comando anterior y pulsar la tecla Enter, el sistema debe responder con:

[sourcecode language=»sql» gutter=»false» wraplines=»false»]
CREATE FUNCTION
[/sourcecode]


11.5.- Crear disparador para lanzar el procedimiento almacenado de prueba

Crearemos un disparador que lanzará el procedimiento almacenado después de cada inserción:

[sourcecode language=»sql» gutter=»false» wraplines=»false»]
prueba_debugger=# CREATE TRIGGER update_tabla_prueba AFTER INSERT
ON tabla_prueba FOR EACH ROW EXECUTE PROCEDURE tabla_prueba_trigger();
[/sourcecode]

y el sistema responde con:

[sourcecode language=»sql» gutter=»false» wraplines=»false»]
CREATE TRIGGER
[/sourcecode]

11.6.- Ejecutar el script de preparacion para la depuración

Para poder depurar los procedimientos almacenados, es necesario que antes hayamos ejecutado en la base de datos donde queremos hacer la depuración el siguiente comando:

[sourcecode language=»sql» gutter=»false» wraplines=»false»]
prueba_debugger=# CREATE EXTENSION pldbgapi;
[/sourcecode]

el sistema responderá con:

[sourcecode language=»sql» gutter=»false» wraplines=»false»]
CREATE EXTENSION
[/sourcecode]

Una vez ejecutado el comando, ya podemos conectarnos a la base de datos desde pgAdminIII y usar la función de depuración.

Nota: Debemos ejecutar este comando en cada base de datos donde deseemos usar la funcionalidad de depuración.



&ld;/p>

11.7.- Probar el depurador

Finalmente, obtendremos la recompensa a nuestro esfuerzo, al abrir pgAdminIII, abrir la base de datos de prueba que hemos creado, abrir el esquema public, abrir la tabla tabla_prueba desplegar la sección Trigger-Functions, y sobre nuestra función, hacer click con el boton derecho, y seleccionar la opción «Set breakpoint»


Estableciendo punto de ruptura con pgAdminIII

Estableciendo punto de ruptura con pgAdminIII

En la siguiente captura podemos ver el depurador en acción:


Depurador pgAdminIII en acción

Depurador pgAdminIII en acción