Como criar uma conex�o em PostgreSQL com Python

Nesse artigo ser�o apresentados dois tipos de configuraç�o para conex�o com o banco de dados PostgreSQL com Python, muito �teis para agilizar o desenvolvimento: utilizando o PSYCOPG, que � considerado o adaptador mais utilizado, e tamb�m o PY-POSTGRESQL, que � considerado um provedor de interface mais otimizado.

Estamos usando para rodar os exemplos deste artigo a interface de desenvolvimento integrado LiClipse, baixando do seu site (vide seç�o Links) e escolhendo a opç�o �Get it Download�.

Ap�s a instalaç�o do mesmo, execute-o e aparecer� uma tela como a da Figura 1.

Figura 1. Seleç�o do workspace

Esta janela se refere � localizaç�o do workspace, ou seja, o local no disco onde v�o ficar os projetos. Para esse artigo vamos usar o valor padr�o dos documentos do usu�rio logado. Depois de selecionado, basta escolher qual o tema desejado, como na Figura 2. Para esse artigo usaremos o primeiro tema.

Figura 2. Escolha do tema

Com isso o LiClipse estar� pronto para ser utilizado, como mostra a Figura 3.

Figura 3. Tela que ilustra como � o menu principal �File� com as opç�es para se trabalhar

PSYCOPG

Uma das maneiras da linguagem Python reconhecer o banco de dados PostgreSQL � atrav�s do adaptador PSYCOPG, que � considerado o mais utilizado.

Saiba mais: Curso de Python

Existem duas maneiras de instal�-lo:

Pelo instalador Windows, que usaremos nesse artigo ou pelo instalador MAC: baixe a vers�o apropriada do PSYCOPG no site (seç�o Links) e execute o instalador na pasta site-packages do Python;
Instalaç�o Manual: baixe o pacote tar.gz em http://initd.org/psycopg/tarballs/PSYCOPG-2-6/psycopg2-2.6.tar.gz e descompacte o arquivo em alguma pasta conhecida. Em seguida, execute o prompt de comando, entre na pasta que voc� descompactou o pacote e acesse a pasta. Rode o seguinte comando para instalar:


c:\Python34\python setup.py install

Configurando A Conex�o Pelo PSYCOPG

Veja na Listagem 1 como configurar a conex�o com o Banco de Dados PostgreSQL utilizando o PSYCOPG. Lembre-se de criar um banco de dados �regiao� num projeto do Liclipse.


import psycopg2
con = psycopg2.connect(host='localhost', database='regiao',
user='postgres', password='postgres123')
cur = con.cursor()
sql = 'create table cidade (id serial primary key, nome varchar(100), uf varchar(2))'
cur.execute(sql)
sql = "insert into cidade values (default,'S�o Paulo,'SP')"
cur.execute(sql)
con.commit()
cur.execute('select * from cidade')
recset = cur.fetchall()
for rec in recset:
print (rec)
con.close()

Listagem 1. Configurando a Conex�o

Veja que o c�digo � respons�vel por criar rotinas de conex�o, tabelas, inserç�o de dados e transaç�es. Na linha 1 importamos a biblioteca PSYCOPG para que seus recursos possam ser utilizados durante a programaç�o do m�dulo. Nas linhas 2 e 3 configuramos a conex�o local ao banco de dados 'regiao'. J� a linha 4 recupera o objeto 'cur' para acesso ao banco. Em seguida montamos um SQL para criar a tabela, que � executado a seguir. Na linha 7 criamos um SQL para inserir uma linha na tabela e a executamos em seguida. A linha 9 força a execuç�o das transaç�es pendentes e na linha 10 executamos um SQL de consulta. Da linha 11 at� a 13 recuperamos e exibimos os resultados e ao final fechamos a conex�o.

O retorno ser�: (1, 'S�o Paulo', 'SP'), como mostra na Figura 4.

Figura 4. C�digo sendo executado e exibido o resultado no Console do LiClipse

O rec tem finalidade em retornar: print rec[0] print rec[1] print rec[2] ... print rec [n], ou seja, todos os registros buscados da tabela.

Modularizando Classe Conex�o

Vamos criar agora uma classe denominada �Conexao�, localizada na Listagem 2, cujo objetivo � modularizar o c�digo criado na Listagem 1 para que a classe se adapte de um modo geral e todo o seu comportamento fique mais r�pido com relaç�o ao tempo de resposta, melhorando o seu desempenho. Note que j� foi criada a tabela �cidade� anteriormente.

 
class Conexao(object):
   _db=None    
   def __init__(self, mhost, db, usr, pwd):
    self._db = psycopg2.connect(host=mhost, database=db, user=usr,  password=pwd)
   def manipular(self, sql):
       try:
           cur=self._db.cursor()
           cur.execute(sql)
           cur.close();
         self._db.commit()
     except:
         return False;
     return True;
 def consultar(self, sql):
     rs=None
     try:
         cur=self._db.cursor()
         cur.execute(sql)
         rs=cur.fetchall();
     except:
         return None
     return rs
def proximaPK(self, tabela, chave):
     sql='select max('+chave+') from '+tabela
     rs = self.consultar(sql)
     pk = rs[0][0]  
     return pk+1
def fechar(self):
     self._db.close()

Listagem 2. C�digo respons�vel por modularizar atrav�s da criaç�o da classe Conexao

Na linha 3 definimos o m�todo __init__() para iniciaç�o com a passagem de par�metros. Em seguida criamos a conex�o com os objetos para o banco de dados: �db�, usu�rio �usr� e senha �pwd�. Al�m disso criamos um m�todo respons�vel por manipular todas as funcionalidades. A linha 7 faz a varredura com o cursor, pesquisando todos os registros do banco de dados para, em seguida, executarmos o SQL.

Nas linhas 9 e 10 fechamos a conex�o e encerramos as transaç�es, respectivamente.

A partir da linha 14 � criado o m�todo para consulta: o objeto �rs� recebe um valor vazio. Na linha 19 esse mesmo objeto recebe o valor total da consulta existente. Na linha 22, se existir algum registro, ent�o esse � retornado para o objeto �rs�. J� na linha 23 � criado o m�todo proximaPK, que � respons�vel por retornar o maior �ndice da chave prim�ria do registro inserido. Depois de executarmos o comando SQL de consulta na linha 24, a linha 26 recupera a primeira coluna da primeira linha, que � retornado para o objeto pk que ser� exibido. A linha 28 cria o m�todo fechar para encerrar a conex�o com o banco de dados.

Para complementar o c�digo da Listagem 2 vamos implementar a seguir o c�digo da Listagem 3, podendo ser em um outro m�dulo, cuja finalidade � para que se assumam todos os valores e comportamentos de conex�o, inserç�o, consulta e transaç�o de um modo breve e simples.


con=Conexao('localhost','regiao','postgres','postgres123')
sql = "insert into cidade values (default,'Rio de Janeiro','RJ')"
if con.manipular(sql):
  print('inserido com sucesso!')
print (con.proximaPK('cidade', 'id'))
rs=con.consultar("select * from cidade")
for linha in rs:
  print (linha)
con.fechar()

Listagem 3. C�digo respons�vel por definir os valores dos par�metros para a conex�o e sua manipulaç�o

O c�digo começa com a criaç�o do objeto �con�, onde � definido o local e nome para o banco de dados, usu�rio e senha respectivamente. Na linha 2 � criado o comando SQL para inserir novos valores (cidade e estado) para a tabela cidade (j� criada anteriormente) Em seguida verificamos se foi inserido o registro anterior. J� a linha 5 imprime a cidade inserida. Na linha 6 � criado o objeto �rs� para recuperar a consulta, que tem os registros impressos na linha 8. Ao final fechamos a conex�o com o banco de dados. O resultado a ser exibido no Console ser� de acordo com a Figura 5, que mostra uma mensagem que foi inserido o registro com sucesso e abaixo os registros que foram inseridos at� o momento.

Figura 5. Tela do Console mostrando uma mensagem que foi inserido o registro com sucesso e abaixo os registros que foram inseridos at� o momento

PY-POSTGRESQL

Agora ser� apresentado o Py-Postgresql, que � um provedor de interface otimizado para conex�o com o banco de dados PostgreSQL e o Python. Para começarmos precisamos primeiro baixar o pacote tar.gz no link da seç�o Links.

Ap�s descompactar o arquivo em alguma pasta conhecida, execute o prompt do DOS e acesse a pasta que voc� descompactou o pacote e rode o seguinte comando:


c:\Python34\python setup.py install

Assim, o Py-postgresql ser� instalado na pasta site-packages do Python.

Configurando a Conex�o pelo Py-Postgresql

Veja na Listagem 4 como configurar a conex�o com o banco de dados PostgreSQL utilizando o adaptador Py-Postgresql. Nesse exemplo ser� poss�vel abrir a conex�o, criar uma tabela, inserir linha de registro e executar as transaç�es em um m�dulo Python. Para esse exemplo precisamos j� ter criado o banco de dados �teste� anteriormente.

 
 import postgresql 
 db = postgresql.open("pq://postgres:postgres123@localhost/teste")
 sql = 'create table cidade (id serial primary key, nome varchar(100), uf varchar(2))'
 db.execute(sql)
 sql = "insert into cidade values (default,'Curitiba,'PR')"
 try:
  db.execute(sql)
 except:
  print ("erro") 
sql = "select * from cidade�
rs=db.prepare(sql)
for linha in rs:
  print (linha)
db.close()

Listagem 4. C�digo respons�vel por fazer a configuraç�o e realizar alguns comportamentos

Começamos o c�digo fazendo a importaç�o do driver postgresql para utilizarmos os seus recursos durante a implementaç�o. Em seguida abrimos a conex�o local no banco de dados teste e montamos um SQL para criar a tabela e executamos. Na linha 5 criamos um SQL para inserir uma linha nessa tabela criada. Da linha 6 at� a linha 9 executamos o bloco try except.

Na linha 10 executamos um SQL de consulta de seleç�o e em seguida preparamos outro comando SQL para ser executado, que por sua vez imprime a consulta, retornando todos os registros. Ao final, na linha 14 fecha a conex�o.

O retorno ser�: (1, 'Curitiba', 'PR'), conforme mostra a Figura 6.

Figura 6. Registro buscado da tabela �teste�

Modularizando a Classe Conex�o

Na Listagem 5 criamos a classe denominada Conexao, cujo fundamento � modularizar o c�digo criado anteriormente na Listagem 4. Para que sua funcionalidade de conex�o fique mais modular precisamos melhorar o desempenho da aplicaç�o e torna-la mais r�pida com relaç�o ao tempo de resposta. Note que j� foi criada a tabela �cidade� anteriormente.

 
import postgresql
class Conexao(object):
   _db=None;
   def __init__(self, banco):
       self._db = postgresql.open(banco)
   def manipular(self, sql):
       try:
           self._db.execute(sql)
       except:
          return False;
      return True;
  def consultar(self, sql):
      rs=None
      try:
          rs=self._db.prepare(sql)
      except:
          return None
      return rs
  def proximaPK(self, tabela, chave):
      sql='select max('+chave+') from '+tabela
      rs = self.consultar(sql)
      pk = rs.first()
      return pk+1
  def fechar(self):
      self._db.close()

Listagem 5. C�digo respons�vel por modularizar a configuraç�o com o banco de dados

Começamos criando a classe Conexao na linha 2. J� na linha 4 � criada o m�todo de iniciaç�o __init__ com o par�metro do banco. Em seguida � criada o objeto que recebe o m�todo para abrir o banco, al�m do m�todo �manipular�, que efetua as transaç�es para executar o SQL. Na linha 12 � definido o m�todo de consulta e o objeto �rs� � criado na linha 14. A partir da linha 15 esse �rs� prepara o SQL para ser executado e, na linha 18, esse mesmo objeto retorna a consulta.

Na linha 19 � criado o m�todo proximaPK, que verifica se a chave prim�ria existe e, em seguida, na linha 20, temos o SQL que faz a consulta do maior �ndice, criado atrav�s do registro inserido. Na linha 21 temos o objeto �rs� recebendo o valor da consulta por SQL. J� na linha 22 temos o objeto pk recebendo o primeiro registro da tabela e em seguida o seu retorn do objeto �pk�. As linhas 24 e 25 criam o m�todo fechar e encerram a conex�o.

Com o objetivo de integrar o c�digo anterior da Listagem 5 vamos implementar a seguir o c�digo da Listagem 6, podendo ser implementado em um outro m�dulo, para que assuma todos os comportamentos e par�metros de conex�o, inserç�o, consulta e transaç�o.

 
import postgresql
from Conexao import *
con=Conexao("pq://postgres:postgres123@localhost/teste")
sql = "insert into cidade values (default,'Bahia','BA')"
if con.manipular(sql):
  print('inserido com sucesso!')
print (con.proximaPK('cidade', 'id'))
rs=con.consultar("select * from cidade")
for linha in rs:
print (linha)
con.fechar()

Listagem 6. Passagem de par�metros

Esse c�digo efetua a passagem de par�metros para conex�o, realiza inserç�o na tabela e retorna seus registros, começando pela linha 2, que faz a importaç�o da classe Conexao. Em seguida � criado o objeto �con' para conex�o com suas diretrizes e nome do banco. Na linha 4 � criado o comando para inserir valores na tabela cidade e na linha 5 verifica-se se foi inserido com sucesso. A linha 7 imprime o maior registro inserido. O objeto rs recebe a consulta da tabela cidade pelo c�digo da linha 8 e na linha 10 imprime-se os registros da tabela. A conex�o � fechada na linha 11.

Veja na Figura 7 o resultado da inserç�o e busca dos registros da tabela �teste� utilizando modularizaç�o.

Figura 7. Console exibindo uma mensagem de inserç�o com sucesso e a retorno de todos os registros armazenados

Vimos nesse artigo como � f�cil instalar e configurar o Psycopg para implementar a API Python DB 2.0, que � usada para conectar a aplicaç�o com o banco PostgreSQL. Com esse adaptador conseguimos que diversas extens�es permitam acesso a muitos dos recursos oferecidos por esse banco, como o thread-safe para usar conex�es diferentes ou compartilhar a mesma configuraç�o.

J� o py- postgresql nos fornece um conjunto de m�dulos em Python para nos ajudar a conversar com o banco por meio de interfaces. Para usar este � interessante ter o Psycopg instalado, pois proporciona uma maior utilidade.

Espero que tenham gostado!

Links: