segunda-feira, 12 de setembro de 2011

PostgreSQL 9.1 Lançado Oficialmente!

A muito aguardada versão 9.1 do PostgreSQL está disponível para download. O destaque são as mudanças relacionadas a performance e replicação, mas existem melhorias em praticamente todos os campos. É baixar, instalar e usar!

Abaixo o texto do anúncio oficial:

------------------------------------------------------------------------------------

The PostgreSQL Global Development Group announces the release of
PostgreSQL 9.1.  This latest version of the leading open source database
offers innovative technology, unmatched extensibility, and new features
such as synchronous replication, K-Nearest Neighbor indexing, and
foreign data wrappers.

"PostgreSQL 9.1 provides some of the most advanced enterprise
capabilities of any open source database, and is backed by a vibrant and
innovative community with proven customer success.  PostgreSQL is well
positioned for building and running applications in the cloud," said
Charles Fan, Sr. VP R&D, VMware.

Responding to Users

Version 9.1 delivers several features which users have been requesting
for years, removing roadblocks to deploying new or ported applications
on PostgreSQL.  These include:

* Synchronous Replication: enable high-availability
  with consistency across multiple servers
* Per-Column Collations: support linguistically-correct
  sorting per database, table or column.
* Unlogged Tables: greatly improves performance for ephemeral data

"Heroku runs the largest PostgreSQL database-as-a-service in the world,"
said James Lindenbaum, Heroku co-founder. "The release of synchronous
data replication with 9.1 provides our customers with innovative new
ways of protecting mission-critical data, and validates PostgreSQL as
one of the fastest-moving datastores available."

Advancing the State of the Art

Our community of contributors innovates with cutting-edge features.
Version 9.1 includes several which are new to the database industry,
such as:

* K-Nearest-Neighbor Indexing: index on "distance" for
  faster location and text-search queries
* Serializable Snapshot Isolation: keeps concurrent transactions
  consistent without blocking, using "true serializability"
* Writeable Common Table Expressions: execute complex multi-stage
  data updates in a single query
* Security-Enhanced Postgres: deploy military-grade security
  and Mandatory Access Control

"OpenERP has always relied on the enterprise-class features of
PostgreSQL to provide a fast, reliable and scalable foundation for the
Business Applications supporting our customers' operations every day.
Data integrity in highly concurrent and transactional contexts is a
critical topic for us, and we're very enthusiastic about the new
Serializable Snapshot Isolation of PostgreSQL 9.1!"  said Olivier Dony,
OpenERP Community Manager.

Extending the Database Engine

PostgreSQL's extensibility enables users to add new functionality to a
running production database, and use them for tasks no other database
system can perform.  Version 9.1 adds new extensibility tools, including:

* Foreign Data Wrappers: attach and query other databases
  from PostgreSQL
* Extensions: easily create, load, and manage new database features

In PostgreSQL's 25th year of database development, our community
continues to advance database technology with every annual release.
Download version 9.1 now and experience the most advanced open source
database system in the world.

More information on PostgreSQL 9.1:
* Release notes
  http://www.postgresql.org/docs/9.1/static/release-9-1
* Presskit
  http://www.postgresql.org/about/press/presskit91
* Guide to 9.0:
  http://wiki.postgresql.org/wiki/What's_new_in_PostgreSQL_9.1

Download 9.1 now:
* Main download page:
  http://www.postgresql.org/download
* Source code:
  http://www.postgresql.org/ftp/source/v9.1.0
* One-click installer, including Windows installer:
  http://www.enterprisedb.com/products/pgdownload.do






sexta-feira, 9 de setembro de 2011

PgBr 2011 - Inscrições Abertas! Último dia para Submissão de Trabalhos!

A PgBr 2011, o maior evento de Postgres do país, está com inscrições abertas. O valor da inscrição aumenta à medida em que se aproxima a data do evento: 3 e 4 de novembro, em São Paulo. A inscrição vip dá direito a almoço com os palestrantes. Se inscreva agora!

Hoje, 09 de setembro, é o último dia para Submissão de Trabalhos!

Serpro Ultrapassa os 200 Bancos de Dados PostgreSQL!



Ao atingir o volume de 220 bancos de dados, o PostgreSQL passa a ocupar a
posição de destaque como tecnologia livre de bancos de dados no Serpro - Serviço Federal de Processamento de Dados. O MySQl apresenta 200 bancos de dados implementados.

Confira esta informação na página 19 da edição 207 da versão online de revista TEMA. Outro artigo com destaque para o Postgres é o do encarte TEMATEC "Expresso em Nuvem", que mostra uma implementação de grande porte com Postgres e PgPool.

quinta-feira, 21 de julho de 2011

A Função clock_timestamp()

Você já ouviu da função clock_timestamp? Ela retorna a data e hora com bastante precisão junto com a time zone do servidor, da mesma forma que as funções now() e current_timestamp. Então para quê implementar esta nova função? O interessante da clock_timestamp é que a mesma retorna o timestamp do término da transação, enquanto now e current timestamp retornam a data/hora do início da transação corrente.

É uma função que pode ser importante para aqueles que necessitam de alta precisão ao lidar com variáveis temporais.

Exemplos:

1 - Sintaxe básica

teste=# SELECT clock_timestamp();
        clock_timestamp       
-------------------------------
 2011-07-21 09:34:12.645251-03
(1 registro)


2 - Extração de parte do valor retornado.

teste=# SELECT SUBSTRING(CAST(now() AS VARCHAR) FROM 1 FOR 10);
 substring 
------------
 2011-07-21
(1 registro)



3 - Lado a lado o resultado de clock_timestamp() e now() na mesma transação. Observe que os valores são diferentes e indicam o timestamp de início e de término da transação.

teste=# SELECT SUBSTRING(CAST(now() AS VARCHAR) FROM 1 FOR 10);
 substring 
------------
 2011-07-21
(1 registro)

teste=# SELECT now() || '   ' || clock_timestamp();
                           ?column?                           
---------------------------------------------------------------
 2011-07-21 10:21:46.592655-03   2011-07-21 10:21:46.592828-03
(1 registro)


4 - Diferença entre clock_timestamp() e now(), mostrando o tempo decorrido entre o início e o término da transação.

teste=# SELECT clock_timestamp() - now();
    ?column?    
-----------------
 00:00:00.000099
(1 registro)

sexta-feira, 15 de julho de 2011

sexta-feira, 1 de julho de 2011

Baixe os RPMs de Instalação da versão 9.1 Beta2!

Os instaladores para linux da versão 9.1 Beta 2 estão disponíveis para quem quiser testar. Esse é mais um indício de que a versão 9.1 logo será oficialmente lançada.

Baixe os RPMs aqui e teste à vontade!

terça-feira, 28 de junho de 2011

JMeter: Brincando de Testar seu Servidor PostgreSQL!

Testes de performance de servidores de bancos de dados são importantes para se avaliar ambientes de produção antes da implantação de projetos que envolvam muitos usuários e grande tráfego de informações. Uma ferramenta boa e estável para este tipo de teste é o Jakarta Jmeter.

Através do JMeter é possível configurar conexões ao servidor, criar requisições JDBC (comandos, chamadas de funções, etc.), submetê-las ao servidor e analisar o resultado da execução. A ferramenta permite ainda criar múltiplas threads simulando um grande número de usuários simultâneos, e executar para cada thread as requisições mais de uma vez, gerando uma grande carga de acessos que testa os limites de carga aceitos pelos bancos de dados.


Adicionalmente, é possível utilizar ouvintes (listeners) para apresentar os resultados da execução dos comandos na forma de tabelas, árvores e gráficos diversos.

O JMeter é compatível com qualquer banco que aceite conexão JDBC, incluindo o postgres e pode testar ainda outros tipos de requisição como ftp e http. Baixe o jmeter agora!

Vamos mostrar as principais etapas de utilização da ferramenta utilizando um teste feito no postgresql.

1. Instalação

Baixe a ferramenta, descompacte os arquivos em uma pasta. Observe que existem vários subdiretórios. As pastas mais relevantes são a LIB e a BIN.

Copie o arquivo do driver jdbc do postgresql (e o dos demais bancos com os quais trabalhar) para a pasta LIB do JMeter.

2. Execução

No windows pode ser utilizado o arquivo jmeter.bat, na pasta BIN da ferramenta (jakarta-jmeter-2.4/bin no meu caso). No Linux existe o arquivo jmeter.sh.

Existe a opção de rodar diretamente do arquivo .JAR, digitando:

java  -jar ApacheJMeter.jar

A tela inicial apresentada é bastante simples, com uma barra de menu e uma árvore onde são apresentados hierarquicamente os comandos dos planos de testes.

A árvore apresenta duas grandes divisões: plano de testes e área de trabalho. A área de trabalho pode ser utilizada para colocar comandos que não serão executados, enquanto que o plano de testes é a parte da treeview que apresenta os comandos do plano que serão executados, sendo que comandos de teste podem ser arrastados livremente entre área de trabalho e plano de testes.




3. Número de Usuários Simulados no Teste

O primeiro passo é definir o número de usuários que seu teste deseja simular.  Se o seu teste tiver muitos usuários, pode ser caracterizado como teste de carga. Caso tenha apenas um, executando uma vez cada comando, pode ser entendido como um teste funcional. Cada plano de testes pode agregar dezenas de requisições (testes) de banco de dados (JDBC), FTP, HTTP, entre outras possibilidades.


Com o botão direito do mouse sobre o plano de trabalho acione o menu "Plano de Testes\ Adicionar\ Threads (Users)\ Grupos de Usuários". A tela mostrada permite que se defina quantos usuários virtuais serão simulados, o tempo de inicialização de cada usuário e o número de vezes que cada usuário simulado executará os próximos comandos do plano de testes. Caso se deseje 100  usuários, executando 10 vezes cada teste, uma execução do plano de testes testará 10000 execuções do plano.



4. Configurando o JDBC

Para fazer testes de banco de dados, devemos configurar a conexão JDBC. 

Com o botão direito do mouse sobre o plano de trabalho acione o menu "Plano de Testes\ Adicionar\ Elemento de Configuração\  Configuração da Conexão JDBC".

A tela mostrada permite que se defina os parâmetros de conexão com o servidor, tais como limite de conexões, tempo máximo de conexão, intervalo para timeout de conexão, entre outros. A figura abaixo mostra os principais parâmetros utilizados.


5. Criação do Teste de Banco

Para criar os testes de banco de dados em si, basta se definir o SQL a ser submetido. O comando será executando tantas vezes forem definidas na seção "Grupo de Usuários" do plano de testes.

Com o botão direito do mouse sobre o plano de trabalho acione o menu "Plano de Testes\ Adicionar\ Testador\ Requisição JDBC".

A tela mostrada permite que se forneça o comando SQL a ser testado. Não utilize ponto e vírgula ";", pois pode gerar erro de execução.



6. Adicionando Ouvintes (Listeners)

Antes de executar os testes, deve ser definido de que forma o resultado da execução será apresentado. Os ouvintes monitoram os testes e apresentam o resumo das execuções de várias formas.

Um mesmo teste pode ser visualizado de mais de uma forma, o que facilita o entendimento, seja como árvore, tabela, gráfico ou geração de arquivo.


Com o botão direito do mouse sobre o plano de trabalho acione o menu "Plano de Testes\ Adicionar\ Ouvinte\ Árvore de Resultados".  Acrescente outros ouvintes como "Relatório Agregado" e "Ver Resultados em Tabela". As figuras abaixo mostra o resultado de um teste visto por mais de um ouvinte.




7. Executando Testes

Utilize a barra de menu para executar os testes:
- "Executar\ Iniciar" - Executa os testes do plano de trabalho atual
- "Executar\ Limpar Tudo" - Limpa os resultados de testes anteriores para nova rodada de testes
- "Arquivo\ Salvar" - Salva o Plano de Testes


Independentemente de termos boas ferramentas como o JMeter, temos sempre de testar as nossas aplicações, e não podemos descuidar dos bancos de dados. O JMeter tem potencial para automatizar boa parte dos testes feitos com bancos de dados sem grande esforço, o que não elimina a necessidade de bons testadores e de cuidado na hora de se realizar e interpretar os resultados apresentados.

Teste o JMeter e me diga o que achou dele! Não se esqueça que a qualidade do seu teste é consequência de um bom plano de testes!

quarta-feira, 15 de junho de 2011

Atualize seus Drivers JDBC3 e JDBC4 para PostgreSQL

Esse link é importante para quem trabalha com JDBC. O site postgresql.org apresenta uma farta oferta de opções de drivers JDBC para o Postgres, além da documentação e detalhes do desenvolvimento.

São disponibilizados drivers para as versões em produção e para as em desenvolvimento do postgres. Confira e atualize seu ambiente!

segunda-feira, 13 de junho de 2011

Conecte o PostgreSQL com o LibreOffice via JDBC!

A interface visual do LibreOffice (BrOffice) é similar à do ACCESS, e muito superior à da interface do psql. Um grande sonho seria poder visualizar e operar o seu banco do postgresql por meio desta interface.

Já falamos aqui da integração BASE-POSTGRESQL via SDBC. No entanto um artigo da revista brasileira do BrOffice mostra como se conectar via JDBC. Acesse aqui o artigo "BASE E POSTGRESQL: Acomodando um elefante no escritório" de Leonardo Cezar.

O texto é bastante didático e bem ilustrado, facilitando a replicação dos procedimentos, e as próximas edições prometem a continuação da matéria detalhando a operacionalização do trabalho com o postgres dentro do LibreOffice Base. É imperdível para quem está procurando uma nova ferramenta visual.

Qual é a versão do seu Postgres?

Você sabe qual é a versão do seu servidor Postgres? Sabe mesmo? E do cliente (estava pensando que é sempre a mesma?)? Ele é 32 ou 64 bits? Para muitos desenvolvedores a resposta é não, e em vários casos nem se sabe como recuperar estas informações.


A melhor maneira de se saber a versão de um servidor banco de dados é simplesmente consultando-a. E no caso do postgresql a função que retorna estas informações é a VERSION().

Exemplo: 
- Consulta padrão:
SELECT version();


Resultado:
PostgreSQL 9.0.4 on i486-pc-linux-gnu, compiled by GCC gcc-4.4.real (Ubuntu 4.4.3-4ubuntu5) 4.4.3, 32-bit
Para recuperar informações de versionamento do cliente do banco deve se utilizar o utilitário psql:

Exemplo:
psql --version

Resultado: 

psql (PostgreSQL) 9.0.4
contém suporte a edição em linha de comando


Agora você pode visualizar facilmente a versão atual do seu postgres. Então é bom passar mais alguma informação sobre como interpretar o número de versionamento.

O postgres é versionado em um sistema de numeração com três números, no formato "A.B.C". A versão de produção atual, seguindo este formato, é a 9.0.4. A sistemática de numeração de versão do postgres pode ser conferida aqui.

- A - Número de versão principal. Quando este número muda significa que aconteceram alterações radicais na estrutura e funcionamento do banco. A versão atual é 9, e não há planejamento para uma versão 10 no momento.

- B - Número de versão secundário. Quando este número muda significa que aconteceram alterações na estrutura e funcionamento do banco que demandam. Os números A e B devem ser considerados em conjunto, e não apenas o primeiro número de versão, pois indicam uma versão em especial. O B da versão atual é 0, mas existe uma versão beta do postgres 9.1 e planejamento da versão 9.2.

- C - Número de atualizações aplicadas à versão "A.B". Na versão 8.4, por exemplo, já foram aplicadas 10 atualizações. O valor inicial de C é 0 e atualmente estamos na versão 9.0.4, indicando que a versão 9.0 já sofreu 4 atualizações. É importante acompanhar os informes de atualização especialmente quando solucionam questões chave de segurança, performance e bugs que afetam de alguma forma o desenvolvimento dos sistemas e a disponibilidade dos servidores de banco.

Que tal conferir agora a versão que está no seu sistema?

quarta-feira, 8 de junho de 2011

Utilize o PSQL como Gerador de Relatórios!

Uma boa maneira de utilizar o utilitário psql é como meio para executar scripts que recuperem informações e as armazenem em arquivos. Desta forma, podemos gerar relatórios de alta relevância e complexidade a um custo mínimo.

A sintaxe abaixo, lê um script de um arquivo de entrada com o programa e o executa no PSQL:

psql -U usuario -d banco_de_dados -f arquivo_de_entrada

Mas como gerar relatórios de forma fácil com o psql? Simplesmente as opções são infinitas, pois podemos mesclar comandos SELECT, funções como a current_timestamp e comandos do psql. A solução depende da sua criatividade.

Abaixo coloco um script simples que recupera informações sobre os objetos do banco. A opção "\o" especifica um arquivo de saída do relatório. Para se executar o script, o mesmo foi gravado no arquivo "entrada.txt" e foi executado no prompt do psql através da chamada "psql -U postgres -d teste -f entrada.txt". O script foi testado no Postgresql 9.0.

\o saida.txt
\echo Cabecalho
SELECT 'Inicio: ' || current_timestamp as Inicio;
\echo Relatorio no Arquivo Saida.txt
SELECT '#####################################################################' AS Titulo UNION ALL
SELECT '### Relatorio de Banco de Dados 1.0 #################################' AS Titulo UNION ALL
SELECT '### Claudio Leopoldino              #################################' AS Titulo UNION ALL
SELECT '### Script para livre distribuição e utilização #####################' AS Titulo UNION ALL
SELECT '### http://postgresqlbr.blogspot.com/ ###############################' AS Titulo UNION ALL
SELECT '#####################################################################' AS Titulo;
\echo Lista de Bancos de Dados
\qecho '#########################################################################################'
\qecho '### Bancos de Dados #####################################################################'
\qecho '#########################################################################################'
\l
\echo Lista de Bancos de Dados com Detalhe
\l+
\echo Lista de Usuarios
\qecho '#########################################################################################'
\qecho '### Lista de Usuarios ###################################################################'
\qecho '#########################################################################################'
\du
\echo Lista de Tabelas
\qecho '#########################################################################################'
\qecho '### TABELAS #############################################################################'
\qecho '#########################################################################################'
\dt
\echo Lista de Tabelas com Detalhe
\dt+
\echo Lista de Tabelas de Sistema
\dtS
\echo Lista de Tabelas de Sistema com Detalhe
\dtS+
\echo Lista de Indices
\qecho '#########################################################################################'
\qecho '### INDICES #############################################################################'
\qecho '#########################################################################################'
\di
\echo Lista de Indices com Detalhe
\di+
\echo Lista de Sequencias
\qecho '#########################################################################################'
\qecho '### SEQUENCIAS###########################################################################'
\qecho '#########################################################################################'
\ds
\echo Lista de Visoes
\qecho '#########################################################################################'
\qecho '### VISOES ##############################################################################'
\qecho '#########################################################################################'
\dv
\echo Lista de Visoes com Detalhe
\dv+
\echo Lista de Visoes de Sistema
\dvS
\echo Lista de Visoes de Sistema com Detalhe
\dvS+
\echo Lista de Privilegios de Acesso
\qecho '#########################################################################################'
\qecho '### PRIVILEGIOS DE ACESSO ###############################################################'
\qecho '#########################################################################################'
\dp
\echo Lista de Large Objects
\qecho '#########################################################################################'
\qecho '### LARGE OBJECTS #######################################################################'
\qecho '#########################################################################################'
\dl
\echo Lista de Funcoes
\qecho '#########################################################################################'
\qecho '### FUNCOES #############################################################################'
\qecho '#########################################################################################'
\df
\echo Lista de Operadores
\qecho '#########################################################################################'
\qecho '### OPERADORES ##########################################################################'
\qecho '#########################################################################################'
\do
\echo Lista de Tipos de Dados
\qecho '#########################################################################################'
\qecho '### TIPOS DE DADOS ######################################################################'
\qecho '#########################################################################################'
\dT
\echo Rodape
SELECT 'Final: ' || current_timestamp as Final; \q


Agora você pode executá-lo e incrementá-lo para extrair e formatar toda informação que você desejar. Pode ainda criar novos e melhores scripts! Explore opções para layouts mais agradáveis, consultas mais específicas e o que mais a sua necessidade exigir e a sua criatividade for capaz de propor!

Como melhorar este relatório? Te convido a compartilhar com a comunidade nos comentários deste post. Sua contribuição é sempre bem vinda!

terça-feira, 31 de maio de 2011

Booktown e outros Bancos de Dados de Exemplo para PostgreSQL

Exemplos de bancos de dados são úteis para o ensino e a aprendizagem sobre as ferramentas e sobre situações práticas que ocorrem no cotidiano dos profissionais da área. Já falei previamente sobre o pagila, mas é sempre bom ter mais opções.

O Booktown é um script que cria o banco de dados de uma livraria completa, incluindo alguns registros e possibilitando um bom banco de dados para testes e ensino de banco de dados. Originalmente, a base booktown foi utilizada nos exemplos do livro Practical PostgreSQL.

Baixe o script aqui.