Enlace Original http://www.postgresql.cl/colabora/conectpythonII.htm

Indice

Para quién es este documento
Objetivo
Primer Paso, Preparando la Base
Segundo Paso, Preparándonos para programar
Nuestro primer programa
Un segundo programa
Nuevos Desafíos
Sitio de Interés

I. Para quién es este documento.

Este documento está orientado a aquellas personas que tengan un manejo y conocimiento básico del funcionamiento y operatividad de PostgreSQL y el lenguaje de programación Python, además de conocer conceptos esenciales de base de datos, y por último tener las ganas de hacer cosas.

Arriba

II. Objetivo.

El objetivo de este pequeño instructivo es mostrar la conectividad e interacción que se puede realizar entre Python y PostgreSQL.

El proceso de instalar y configurar PostgreSQL se omitirá en esta ocasión, ya que pienso que existe la documentación necesaria para este fin en las siguientes URL:
http://postgresql.org/docs y http://www.postgresql.cl/

Para desarrollar estas actividades utilice:

* Linux Red Hat 8.0 (2.4.18-14)
* PostgreSQL-7.2.2-1
* Python-2.2.1-17

La idea final es crear una base de datos con la cual podamos interactuar a través de Python.

Arriba

III. Primer Paso, Preparando la Base.

Una vez instalado y configurado PostgreSQL (gracias a Dios que existe rpm) procedemos a realizar la creación de nuestra base de datos.

Como primer paso, desde el usuario postgres creamos una nueva base de datos.

$ createdb music
CREATE DATABASE

Una vez creada nuestra base de datos procedemos a conectarnos a ella para crear nuestro pequeño pero poderoso sistema:

$ psql music
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

music=#

Dentro de este terminal “interactivo” de Postgres crearemos las tablas necesarias.

Creando la tabla Bandas:

Esta tabla contendrá nuestras bandas musicales favoritas.

music=# CREATE TABLE BANDA(ID_BANDA INTEGER PRIMARY KEY,
music(# NOMBRE VARCHAR(50));

NOTICE: CREATE TABLE/PRIMARY KEY will create implicit index 'banda_pkey'for'
NOTICE: CREATE TABLE/PRIMARY KEY will create implicit index 'banda_pkey'for'
CREATE

La descripción de la estructura de la tabla es la siguiente:

ID_BANDA: Es un identificador numérico único.
NOMBRE: Corresponde al nombre de la banda.

Creando la tabla Discos:

La tabla discos contendrá los discos de las bandas musicales registradas en la tabla bandas.

music=# CREATE TABLE DISCO(ID_DISCO INTEGER PRIMARY KEY,
music(# NOMBRE VARCHAR(100),;
music(# ID_BANDA INTEGER);

NOTICE:CREATE TABLE / PRIMARY KEY will create implicit index 'disco_pkey' for'
NOTICE:CREATE TABLE / PRIMARY KEY will create implicit index 'disco_pkey' for'
CREATE

La estructura de la tabla DISCO es la siguiente:

ID_DISCO: Es el identificador numérico del disco.
NOMBRE: Es el titulo del disco.
ID_BANDA: Es el identificador de la banda, referencia a la tabla BANDA.

Es obvia la relación existente entre estas dos tablas; una banda puede tener muchos discos y un disco es grabado por una banda.

Para facilitar el trabajo más adelante, procedemos a crear algunos registros.

Insertamos una banda:

music=# INSERT INTO BANDA VALUES(1,'KISS');
INSERT 32953 1

Luego procedemos a insertar discos pertenecientes a esta gloriosa banda.

music=# INSERT INTO DISCO VALUES(1,'LOVE GUN',1);
INSERT 32954 1
music=# INSERT INTO DISCO VALUES(2,'KISS',1);
INSERT 32955 1
music=# INSERT INTO DISCO VALUES(3,'DISTROYER',1);
INSERT 32956 1

Podemos verificar realizando la siguiente consulta.

music=# SELECT A.NOMBRE,A.ID_BANDA,B.ID_BANDA,B.NOMBRE
music-# FROM BANDA A,
music-# DISCO B
music-# WHERE A.ID_BANDA = B.ID_BANDA;

nombre | id_banda | id_banda | nombre
-------+----------+----------+-----------
KISS | 1 | 1 | LOVE GUN
KISS | 1 | 1 | KISS
KISS | 1 | 1 | DISTROYER

Arriba

IV. Segundo Paso, Preparándonos para programar.

Antes que todo, ¿Por qué Python?, y ¿por qué no mejor PHP o Perl?
Sin desmerecer las grandes ventajas y funcionalidades de PHP, pienso que un lenguaje como Python nos entrega una potencialidad adicional al manejar el concepto de Orientación a Objeto, ya que de esta forma podemos “modular” las reglas de negocio de un Sistema de mejor manera, sobre todo si consideramos que existen ciertos Sistemas que son escalables en el tiempo. Aunque si reflexionamos un poco podemos concluir que, básicamente las aplicaciones de Internet que se conectan a una base de datos para generar páginas dinámicas (o interactúan con el usuario) en tres pasos:

1. Apertura de un Canal
2. Realización de la Transacción (SELECT, INSERT, UPDATE, DELETE) a través del Canal.
3. Cierre del canal.

Sin embargo, para aquellos tipos de aplicaciones que contienen o requieren una mayor “inteligencia” asociada se debe considerar lenguajes como Python .

Arriba

V. Nuestro primer programa:

Dentro de una cuenta de usuario que tenga acceso a las librerías y ejecutables correspondientes realizaremos nuestro primer programa.

Lo primero es verificar que nuestro ambiente de trabajo tenga acceso a los componentes necesarios.

Verificación de las librerías y ejecutables de PostgreSQL.

[python@localhost bd]$ pg_config --libdir --bindir

/usr/lib

/usr/bin

Este comando nos permite verificar que tenemos acceso a las librerías y ejecutables de PostgreSQL, respectivamente:

Para verificar que tenemos acceso a Python verificamos el directorio /usr/bin donde debiese encontrarse el utilitario python.

En caso de no contar con este ambiente debemos setearlo mediante la definición de las respectivas variables de ambiente.

$ PATH = $PATH:/:/
$ export PATH

$ LD_LIBRARY_PATH = $LD_LIBRARY_PATH:/:/
$ export LD_LIBRARY_PATH

Una vez verificado que el ambiente de trabajo sea el adecuado realizaremos nuestro primer programa en Python para conectarse a PostgreSQL. La idea es conectarnos a la base de datos music y consultar las bandas y los discos existentes.

Con cualquier editor creamos el archivo conectividad.py y escribimos lo siguiente.

import pg

usuario = 'postgres'

base = 'music'

conecta = pg.connect(dbname=base,user=usuario)

consulta = 'select a.nombre, b.nombre from banda a,
disco b where a.id_banda = b.id_banda'

resultado = conecta.query(consulta)

print resultado

conecta.close()

Al ejecutar este programa desde la línea de comandos tenemos el siguiente resultado:

[python@localhost bd]$ python conectividad.py

nombre | nombre
---------+---------
KISS | LOVE GUN
KISS | KISS
KISS | DISTROYER

(3 rows)

Si analizamos nuestro primer programa nos damos cuenta que la interacción ocurre en tres pasos.

1. Primero se “abre” el canal.

conecta = pg.connect(dbname=base,user=usuario)

2. Luego se realiza la transacción SQL.

consulta = 'select a.nombre, b.nombre from banda a,
disco b where a.id_banda =b.id_banda'

resultado = conecta.query(consulta)

3. Para finalmente cerrar la conexión.

conecta.close()

Importante:

Se debe considerar que toda conexión a PostgreSQL está definida en el archivo de configuración pg_hba.conf (Acceso Basado en el Host). De esta configuración depende que parámetros serán necesarios para conectarse a la base de datos. Debido a que yo tengo configurado el acceso de la siguiente manera, sólo es necesario indicar la base de datos y el usuario que se conectará.

TYPE
local DATABASE
all

AUTH_TYPE
trust

Esta configuración le indica a PostgreSQL que:
a) La conexión se realizará en forma local (Dentro del equipo),
b) que se permite el acceso a todas las bases de datos definidas y
c) que siempre “confíe” (Es decir que no pida la password).

Desglosando línea a línea nuestro primer programa tenemos:

import pg

Importamos el módulo donde se definen los métodos y procedimientos de conectividad
e interacción con PostgreSQL.

usuario = 'postgres'
base = 'music'

Definimos las variables usuario y base, los cuales indicarán a que base de datos conectarnos y bajo que usuario. Como se señaló anteriormente estas variables se utilizan producto de la configuración del archivo pg_hba.conf.

conecta = pg.connect(dbname=base,user=usuario)

En esta línea se realiza la conexión con la base de datos mediante el paso de los parámetros dbname y user. Esta función nos devuelve un objeto pgobject.

consulta = 'select a.nombre, b.nombre from banda a,
disco b where a.id_banda = b.id_banda'

En esta línea definimos nuestra consulta (Transacción)

resultado = conecta.query(consulta)

La función query() es un método definido para pgobject, en este caso conecta.
Si la consulta se ejecuta sin inconvenientes se retorna una objeto pgqueryobjet, el cual, en este caso es asignado a resultado.

print resultado

Luego print nos muestra los resultados en el formato definido por el objeto pgqueryobjet.

conecta.close()

Por último se realiza el cierre de la conexión.

Como se puede apreciar, la programación que se puede realizar utilizando Python no difiere en gran medida de los conceptos y metodologías de otros lenguajes de programación.

Arriba

VI. Un segundo programa:

Ya que vimos como recuperar datos mediante una simple consulta a la base de datos ahora veremos como insertar nuevos registros en la tabla BANDA de nuestro pequeño Sistema.

Si vemos el siguiente código nos damos cuenta que es similar al anterior, lo único que cambia es la transacción.

import pg

usuario = 'postgres'
base = 'music'

id = '2'
nombre = 'LED ZEPPELIN'

conecta = pg.connect(dbname=base,user=usuario)

inserta = 'insert into banda values('+id+',\''+nombre+'\')'

print inserta
print

resultado = conecta.query(inserta)

print resultado

conecta.close()

Dentro del nuevo código distinguimos la declaración de las variables: ID y NOMBRE, las cuales contienen el identificador y nombre de la nueva banda que vamos a insertar.

id = '2'
nombre = 'LED ZEPPELIN'

Como vemos en el string que conforma la transacción “inserta”, el INSERT es armado utilizando la concatenación (+) y el carácter que permite que se utilicen las comillas simples dentro del mencionado string (\).

inserta = 'insert into banda values('+id+',\''+nombre+'\')'

La línea con el print inserta despliega por pantalla como quedo conformada la transacción:

print inserta

De esta forma al ejecutar nuestro nuevo programa se obtiene el siguiente resultado:

[python@localhost bd]$ python insertando.py

insert into banda values(2,'LED ZEPPELIN')
32961

Arriba

VII. Nuevos Desafíos:

Lo que nos queda como desafío es la configuración y conectividad a PostgreSQL a través de nuestro servidor Apache y la utilización del mod_python. Otro desafío es la utilización de todas las potencialidades de Python como lenguaje Orientado a Objeto en el desarrollo de Sistemas de Información.

Arriba

VIII. Sitios de Interés:

Python
http://www.python.org

PostgreSQL
http://www.postgresql.org
http://www.postgresql.cl