Bom, vamos ao que interessa:

1. Window Funcions (desde a 8.4) [1]: maneira de fazer funções de agregação (sum, avg, etc.) em pedaços retornados da sua query sem ter que fazer group by e retornar uma linha, simplesmente fantástico. Para relatórios é algo crucial, principalmente em relatórios comerciais. Aqui na empresa estamos a desenvolver um relatório destes e, como não sabíamos destas novas funcionalidades, passamos maus bocados.
2. When Triggers: possibilidade de colocar condições para execução de triggers como:

    CREATE TRIGGER log_update
    AFTER UPDATE ON accounts
    FOR EACH ROW
    WHEN (OLD.* IS DISTINCT FROM NEW.*)
    EXECUTE PROCEDURE log_account_update();

   Assim, sua trigger só será executada quando algum valor for modificado, evitando as antigas e complicadas verificações que fazíamos dentro das triggers em nossos famigerados OLD’s e NEW’s.

3. Colum Triggers:
   Condicionamento da execução de uma trigger através da modificação de uma coluna, algo bem útil também e mais direto que o dito acima.

    CREATE TRIGGER foo
    BEFORE UPDATE OF some_column ON table1
    FOR EACH ROW EXECUTE PROCEDURE my_trigger()

4. Hot Standby e Stream Replication: duas ferramentas de replicação de dados contínua que podem trabalhar em conjunto. A ideia básica é ter bancos replicados que possam servir tanto de backup ou quanto, por exemplo, um para pesquisas e outro para atualizações DML. Isto pode diminuir a carga de um determinado sistema. Além disto é uma ferramenta “included” que irá fazer algo que antigamente só era feito por ferramentas de terceiros, um dos grandes diferenciais desta nova versão.
5. Ordenação em funções de agregação: primeiro observem a nova e sensacional ferramenta, string_agg (uma função de agregação para strings, bem como a outra nova array_agg). Desta forma estamos fazendo a agregação  dos nomes com muita facilidade.

    marc=# SELECT entity,string_agg(name,', ')
           FROM salary GROUP BY entity;
    entity     |          string_agg
    -----------+-------------------------------
    Accounting | stephanie, etienne
    R&D        | marc, maria, kevin, john, tom

   Mas o mais legal não é isto. Estas funções novas também aceitam uma simples e fácil ordenação, vejam:

    marc=# SELECT entity,string_agg(name,', ' ORDER BY name)
           FROM salary GROUP BY entity;
    entity     |          string_agg
    -----------+-------------------------------
    Accounting | etienne, stephanie
    R&D        | john, kevin, marc, maria, tom

   Percebam que esta ordenação é feita no pequeno conjunto de dados da agregação conforme sempre sonhamos.

6. Melhores mensagens de erro:
   Com 8.4:

    marc=# INSERT INTO test VALUES (1);
    ERROR:  duplicate key value violates unique
            constraint "test_a_key"

   Com 9.0:

    marc=# INSERT INTO test VALUES (1);
    ERROR:  duplicate key value violates unique
            constraint "test_a_key"
    DETAIL:  Key (a)=(1) already exists.

   Estes detalhes ajudam muito a encontrar erros na hora do desenvolvimento.

7. Remoção de Join desnecessário:
   A ideia é basicamente otimizar queries automaticamente. Se eu tenho 3 tabelas:

CREATE TABLE t1 (a int);
CREATE TABLE t2 (b int);
CREATE TABLE t3 (c int);
Com o campo c na tabela t3 tendo uma constraint unique,
feita por:
ALTER TABLE t3 ADD UNIQUE (c);
E fizermos um:
EXPLAIN SELECT t1.a,t2.b from t1 join t2 on (t1.a=t2.b) 
left join t3 on (t1.a=t3.c);

No 8.4 teremos este resultado, sem nenhuma otimização 
"automática", veja:
                            QUERY PLAN
------------------------------------------------------------------
Merge Join  (cost=338.76..790.56 rows=28800 width=8)
  Merge Cond: (t1.a = t2.b)
  ->  Merge Left Join  (cost=170.01..183.81 rows=2400 width=4)
      Merge Cond: (t1.a = t3.c)
      ->  Sort  (cost=168.75..174.75 rows=2400 width=4)
          Sort Key: t1.a
          ->  Seq Scan on t1  (cost=0.00..34.00 rows=2400 width=4)
      ->  Sort  (cost=1.27..1.29 rows=10 width=4)
          Sort Key: t3.c
          ->  Seq Scan on t3  (cost=0.00..1.10 rows=10 width=4)
  ->  Sort  (cost=168.75..174.75 rows=2400 width=4)
          Sort Key: t2.b
          ->  Seq Scan on t2  (cost=0.00..34.00 rows=2400 width=4)
Com este mesmo script executado no 9.0, teremos um resultado
otimizado, veja:
                            QUERY PLAN
------------------------------------------------------------------
Merge Join  (cost=337.49..781.49 rows=28800 width=8)
  Merge Cond: (t1.a = t2.b)
  ->  Sort  (cost=168.75..174.75 rows=2400 width=4)
        Sort Key: t1.a
        ->  Seq Scan on t1  (cost=0.00..34.00 rows=2400 width=4)
  ->  Sort  (cost=168.75..174.75 rows=2400 width=4)
        Sort Key: t2.b
        ->  Seq Scan on t2  (cost=0.00..34.00 rows=2400 width=4)
Isto ocorre porque nesta nova versão, o PostgreSQL consegue
identificar que o campo c é um campo com uma constraint unique,
assim, o LEFT JOIN entre as tabelas t2 e t3
(como temos um on (t1.a = t3.c)) nunca retornarão mais rows,
uma vez que c é única e ele decide por não executar este join,
uma vez que ele é desnecessário.

8. IS NOT NULL agora utiliza indexes:
   Quando queries que envolvem campos nulos são executadas nas versões
   8.* os filtros checam arbitrariamente  nas tabelas pelos valores, nesta nova
   versão, a nulidade do campo também é indexada, assim, ao fazer uma query
   que envolve esta questão, o PostgreSQL irá apenas escanear o index para
   encontrar o elemento necessário, o que faz com que, em muitos casos,
   consultas executem dezenas de vezes (e até centenas) mais rapidamente.
9. Chamadas de parâmetro (em procedures) nomeadas: esta é uma outra functionalidade
   sensacional. Se temos uma função teste com dois parâmetros a e b, antigamente só podíamos chamá-la assim:
   SELECT test(‘valor1′, ‘valor2′);
   
   Agora podemos fazer também:
   SELECT test( a := ‘valor1′, b:= ‘valor2′);
   
   Isto dá mais legibilidade ao código e mais flexibilidade.

Quem quiser saber mais leia [2], tem-se uma descrição bem mais completa de cada nova funcionalidade e seus pormenores, alguns até mesmo sobre implementação.

1 – http://www.depesz.com/index.php/2009/01/21/waiting-for-84-window-functions
2 – http://wiki.postgresql.org/wiki/What’s_new_in_PostgreSQL_9.0

Este meu primeiro post que me integra à blogosfera tem um caráter muito especial para mim. Ele denota o início de um trabalho que tem um intuito categórico: difundir a linguagem Python em Minas Gerais e criar uma comunidade forte de usuários desta linguagem em nosso estado.

A história

Nunca entendi o porquê de Minas Gerais não ter uma comunidade forte desta linguagem. Nós temos aqui uma sede do Google (que é um marketing e tanto para o Python), temos boas universidades como UFMG e PUC onde conheço alguns entusiastas e desenvolvedores Python e temos algumas empresas (como a 2XT na qual trabalho) que tem parte da sua tecnologia baseada na linguagem do Guido, e mesmo assim não formamos ainda nenhum grupo ou comunidade relacionado a estudos nesta linguagem.
Trabalho com Python há alguns anos e sou apaixonado pela linguagem. Tenho experiência com outras linguagens como C, C++, Java e Object Pascal e em nenhuma delas tive tão fácil aprendizado com tanta desenvoltura como tive em Python, a facilidade simplesmente me impressionou. Desta forma penso que quando se é beneficiado com algo surge a responsabilidade de beneficiar à outras pessoas conforme fui beneficiado por aquele que me indicou Python pela primeira vez. Esta responsabilidade se transformou em vontade que impulsionada pelo Small Acts Manifesto me faz escrever este post chamando a todos os mineiros pythonistas a participarem e fortalecerem o Python em Minas Gerais e, por conseguinte, no Mundo.

Os objetivos

Como já não sou o único nesta empreitada à partir daqui me referirei a nós, não a mim. A comunidade já conta com alguns participantes mesmo antes de ser criada (cerca de 5 pessoas). Gostaria que todos tivessem em mente que o intuito desta comunidade não é somente aprender e disseminar Python. Este é apenas o motivo principal pelo qual nos unimos. O objetivo principal desta comunidade é cultivar e difundir o conhecimento.

Conclusão

Portanto, chamo a todos os mineiros que gostam de Python, querem conhecer a linguagem ou são curiosos para participar conosco. Lembrem-se de informar aos seus amigos que este movimento se inicia. Vamos fazer esta comunidade crescer, afinal “Small Acts Make Great Revolutions”.

• Agrupe-se na python-mg.