make all

cd /usr/src/universe && make all

Archive for março \29\UTC 2008

Como obter ajuda sobre PostgreSQL?

Posted by Guedes em março 29, 2008

Como obter ajuda sobre PostgreSQL?Um dos fatores fundamentais que movimenta o universo do software livre é justamente a grande quantidade de usuários que estão prontos (e qualificados) para ajudá-lo desde as dúvidas mais simples, até as mais “cabeludas”. Pois bem, nesses mesmo barco, onde todos estamos remando, existe um “pacto”, não chega a ser uma ordem ou lei, mas sim um pré-requisito básico, que todo aquele que quer entrar nesse universo deveria se certificar de checar, um ação simples: antes de perguntar, pesquise!

Sim, é muito comum ver perguntas recorrentes na lista pgbr-geral em que muitos de seus questionadores não se deram o luxo de, no mínimo, dar uma googlada. Conclusão? Muitas vezes eles acabam saindo frustrados com uma resposta default: “Veja o histórico da lista.”

Já outros possuem espírito aventureiro, questionam-se noite e dia, procuram, encontram, testam, erram, procuram, encontram, testam, acertam … e nesse ciclo rumo ao conhecimento, algumas perguntas surgem, duvidas pelas quais alguns de nos passamos também, cujas respostas não encontramos em uma ferramenta de busca, mas sim nas entrelinhas do conhecimento alheio. E nesse caso, onde buscar então? É ruim perguntar na lista? Não! É perfeito! As respostas mais básicas estão la no histórico da lista… algumas complexas também… e você percebe a diferença entre elas pelo número de threads que um tópico mais complexo pode gerar. Veja como exemplo quantos tópicos sobre Codificação de caracteres já surgiram esse mês.

Em resumo, antes de perguntar leia o site oficial do PostgreSQL, ou o site brasileiro, veja o histórico de nossas listas, procure no Planeta PostgreSQL pesquise no Google. Ainda assim você tem dúvidas cujas respostas dependem da opinião e experiência de outros colegas? Perfeito, pergunte na lista ou procure-nos no IRC. Sim, no IRC… lembra? Lá a resposta pode ser mais rápida, ou a discussão poderá ser mais dinâmica.

Se você possui um cliente de IRC, basta acessar o servidor irc.freenode.net e entrar nos canais #postgresql e #postgresql-br. Ou se preferir, você pode utilizar o Pidgin para conectar, o que não é difícil, basta seguir este filme que mostra passa a passo como fazer:

Como obter ajuda sobre PostgreSQL?Como conectar no canal #postgresql-br da FreeNode via PidGin? [2MB ogg]

Como obter ajuda sobre PostgreSQL?Como conectar no canal #postgresql-br da FreeNode via PidGin? [7MB avi]

Bom, é isso “:D

Posted in postgresql | Etiquetado: , , , , | 1 Comment »

Últimos dias para envio de propostas para Google Summer of Code 2008

Posted by Guedes em março 28, 2008

Últimos dias para envio de propostas para Google Summer of Code 2008Que tal aproveitar o tempo livre para contribuir para a comunidade FreeBSD? Ideias é que não faltam!

O período para submissão encerra neste dia 31 de março e nem é difícil se inscrever, as instruções passo-a-passo encontram-se aqui. Você tem a chance de ter sua aplicação aprovada por algum mentor, contribuir para a comunidade e ainda ganhar brindes e dinheiro. Para quem tem uma boa monografia, dissertação ou tese vale a pena tentar.

Links importantes:

http://www.freebsd.org/projects/summerofcode.html
http://code.google.com/soc/2008/
http://groups.google.com/group/google-summer-of-code-announce/web/guide-to-the-gsoc-web-app-for-student-applicants
http://groups.google.com/group/google-summer-of-code-discuss

Bom, é isso! “:D

Posted in freebsd | Etiquetado: , , | 2 Comments »

ALTER TABLE em massa no PostgreSQL…

Posted by Guedes em março 27, 2008

ALTER TABLE em massa no PostgreSQL...Você já se deparou com a necessidade de fazer uma alteração que afeta vários campos de várias tabelas? Imagine a seguinte situação: você possui vários campos em diversas tabelas que representam valores monetários de 10 casas inteiras e 2 decimais, ou seja, tipo numeric(12,2), e por necessidade do cliente o analista informou que isso precisa ser alterado para 15 casas inteiras e 2 decimais, ou seja, tipo numeric(17,2). E agora?

Bem, nosso amigo elefante que nunca esquece, guarda esses dados com bastante carinho e permite que nós, meros mortais, possamos visualizá-los e tomar decisões com eles já que cada banco de dados possui um esquema contendo os dados sobre os seus dados – os metadados. O nome desse esquema é information_schema e contém views que nos permitem, por exemplo, listar os campos de uma tabela com seus respectivos tipos, essa view é declarada como columns. Então o que tem nela?

  SELECT * FROM information_schema.columns;(saída muito grande aqui ...)

Testou? “Coisarada” né? Mas que tal listar as colunas de uma tabela especifica? Suponha que exista uma tabela ‘tb_pessoa’:

SELECT *  FROM information_schema.columns  WHERE table_name =  'tb_pessoa';


 table_catalog | table_schema |  table_name   |      column_name       | ordinal_position | column_default | is_nullable |          data_type          | character_maximum_length | character_octet_length | numeric_precision | numeric_precision_radix | numeric_scale | datetime_precision | interval_type | interval_precision | character_set_catalog | character_set_schema | character_set_name | collation_catalog | collation_schema | collation_name | domain_catalog | domain_schema | domain_name | udt_catalog | udt_schema | udt_name  | scope_catalog | scope_schema | scope_name | maximum_cardinality | dtd_identifier | is_self_referencing
---------------+--------------+---------------+------------------------+------------------+----------------+-------------+-----------------------------+--------------------------+------------------------+-------------------+-------------------------+---------------+--------------------+---------------+--------------------+-----------------------+----------------------+--------------------+-------------------+------------------+----------------+----------------+---------------+-------------+-------------+------------+-----------+---------------+--------------+------------+---------------------+----------------+---------------------
 esquema       | esquema      | tb_pessoa     | tipo_pessoa            |                3 |                | NO          | integer                     |                          |                        |                32 |                       2 |             0 |                    |               |                    |                       |                      |                    |                   |                  |                |                |               |             | esquema     | pg_catalog | int4      |               |              |            |                     | 3              | NO
 esquema       | esquema      | tb_pessoa     | nome                   |                2 |                | NO          | character varying           |                      150 |             1073741824 |                   |                         |               |                    |               |                    |                       |                      |                    |                   |                  |                |                |               |             | esquema     | pg_catalog | varchar   |               |              |            |                     | 2              | NO
 esquema       | esquema      | tb_pessoa     | nome_personalizado     |                9 |                | YES         | character varying           |                       25 |             1073741824 |                   |                         |               |                    |               |                    |                       |                      |                    |                   |                  |                |                |               |             | esquema     | pg_catalog | varchar   |               |              |            |                     | 9              | NO
 esquema       | esquema      | tb_pessoa     | dt_inclusao            |                5 |                | NO          | date                        |                          |                        |                   |                         |               |                    |               |                    |                       |                      |                    |                   |                  |                |                |               |             | esquema     | pg_catalog | date      |               |              |            |                     | 5              | NO
 esquema       | esquema      | tb_pessoa     | nro_documento          |                1 |                | NO          | numeric                     |                          |                        |                14 |                      10 |             0 |                    |               |                    |                       |                      |                    |                   |                  |                |                |               |             | esquema     | pg_catalog | numeric   |               |              |            |                     | 1              | NO

Melhorou né? Mas que tal agora mostrar só o que interessa? Como por exemplo, o nome ta tabela, o nome da coluna, o tipo da mesma e se ela aceita nulo?

SELECT    table_name      AS nome_tabela,

column_name     AS nome_coluna,

data_type       AS tipo,

is_nullable     AS aceita_nulo

FROM

information_schema.columns

WHERE

table_name = 'tb_pessoa';

nome_tabela  |      nome_coluna       |            tipo             | aceita_nulo

---------------+------------------------+-----------------------------+-------------

tb_pessoa     | tipo_pessoa            | integer                     | NO

tb_pessoa     | nome                   | character varying           | NO

tb_pessoa     | nome_personalizado     | character varying           | YES

tb_pessoa     | dt_inclusao            | date                        | NO

tb_pessoa     | nro_documento          | numeric                     | NO

Melhor ainda né? Se você analisar a descrição da view columns perceberá que pode melhorar a saida acima. Vejamos:

                      Visão "information_schema.columns"          Coluna          |                Tipo                | Modificadores

--------------------------+------------------------------------+---------------

table_catalog            | information_schema.sql_identifier  |

table_schema             | information_schema.sql_identifier  |

table_name               | information_schema.sql_identifier  |

column_name              | information_schema.sql_identifier  |

ordinal_position         | information_schema.cardinal_number |

column_default           | information_schema.character_data  |

is_nullable              | information_schema.character_data  |

data_type                | information_schema.character_data  |

character_maximum_length | information_schema.cardinal_number |

character_octet_length   | information_schema.cardinal_number |

numeric_precision        | information_schema.cardinal_number |

numeric_precision_radix  | information_schema.cardinal_number |

numeric_scale            | information_schema.cardinal_number |

datetime_precision       | information_schema.cardinal_number |

interval_type            | information_schema.character_data  |

interval_precision       | information_schema.character_data  |

character_set_catalog    | information_schema.sql_identifier  |

character_set_schema     | information_schema.sql_identifier  |

character_set_name       | information_schema.sql_identifier  |

collation_catalog        | information_schema.sql_identifier  |

collation_schema         | information_schema.sql_identifier  |

collation_name           | information_schema.sql_identifier  |

domain_catalog           | information_schema.sql_identifier  |

domain_schema            | information_schema.sql_identifier  |

domain_name              | information_schema.sql_identifier  |

udt_catalog              | information_schema.sql_identifier  |

udt_schema               | information_schema.sql_identifier  |

udt_name                 | information_schema.sql_identifier  |

scope_catalog            | information_schema.sql_identifier  |

scope_schema             | information_schema.sql_identifier  |

scope_name               | information_schema.sql_identifier  |

maximum_cardinality      | information_schema.cardinal_number |

dtd_identifier           | information_schema.sql_identifier  |

is_self_referencing      | information_schema.character_data  |

SELECT

table_name        AS nome_tabela,

column_name       AS nome_coluna,

data_type         AS tipo,

numeric_precision AS digitos,

numeric_scale     AS decimais,

is_nullable       AS aceita_nulo

FROM

information_schema.columns

WHERE

data_type = 'numeric';

Agora só falta juntar tudo isso numa panela, cozinhar por alguns minutos e servir o script que irá satisfazer o nosso problema inicial (lembra? mudar de numeric(12,2) para numeric(17,2)):

SELECT     'ALTER TABLE '   || table_name  ||

' ALTER COLUMN ' || column_name ||

' TYPE numeric(17,2);'

FROM

information_schema.columns

WHERE

data_type = 'numeric'  AND

numeric_precision = 12 AND

numeric_scale     = 2;

?column?

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

ALTER TABLE tb_funcionario ALTER COLUMN remuneracao_basica TYPE numeric(17,2);

ALTER TABLE tb_pessoa_juridica ALTER COLUMN valor_receita TYPE numeric(17,2);

ALTER TABLE tb_fonte_renda_pf ALTER COLUMN valor_renda TYPE numeric(17,2);

ALTER TABLE tb_caixa ALTER COLUMN saldo_dia TYPE numeric(17,2);

--- CORTE ---

Pronto, ai está o nosso script! Você precisa apenas executá-lo agora.

DESAFIO: como a saida do comando SQL é grande, redirecione a saida para um arquivo e execute-o via psql.

Bom, é isso “:D

Posted in postgresql | Etiquetado: , , , | 4 Comments »

Será que meu dump foi gerado com sucesso?

Posted by Guedes em março 26, 2008

Será que meu dump foi gerado com sucesso? Uma das atividades mais comuns de um DBA é a geração do arquivo de dump de suas bases de dados, que nada mais é do que um arquivo contendo a imagem do seu banco de dados em um determinado instante do tempo. Como existem ferramentas de linha de comando que geram esses arquivos, é bastante comum utilizá-las em scripts autônomos, agendados diariamente no período noturno. Mas nem tudo são flores e podemos ser supreendidos ao saber que justo aquele dump que precisávamos não foi executado com sucesso. E agora?

Bom, como já diz o ditado “é melhor prevenir do que remediar”… então, que tal melhorar o script que gera o dump?

AVISO: os passos a seguir não se aplicam ao S.O. Windows ‘puro’, você precisa ter o Cygwin instalado!

Nos sistemas operacionais unix-like possuimos a saida padrão (conhecida por stdout, cujo descritor de arquivo é 1), a saída padrão de erros (conhecida por stderr, cujo descritor de arquivo é 2) e a entrada padrão (conhecida por stdin, cujo descritor de arquivo é 0). Estes recursos podem ser utilizados para redirecionar as saidas de nossos programas. No caso do nosso amigo pg_dump geralmente utilizamos ele assim:

postgres@meu_banco ~$ pg_dump meu_banco > meu_banco.dump

O que estamos fazendo, nada mais é do que redirecionar a saída padrão (stdout) do pg_dump para um arquivo chamado ‘meu_banco.dump’. Mas e se ocorrer algum imprevisto, como falta de espaço em disco, por exemplo? Neste caso, podemos redirecionar a saída de erros (que por padrão é a console) para um arquivo com o seguinte comando:

postgres@meu_banco ~$ pg_dump meu_banco > meu_banco.dump 2> meu_banco.erro

A única diferença foi a adição de ‘2> meu_banco.erro’ ao final do comando. No caso isso indica que os dados enviados para a saída padrão de erros (stderr, descritor de arquivo 2), devem ser redirecionados para o arquivo ‘meu_banco.erro’. Sendo assim, após o comando ter sido executado, pode-se verificar se o arquivo ‘meu_banco.erro’ está vazio (indicando sucesso na operação) ou contém algo (indicando que houve erro).

Este método é interessante porque você guarda o erro ocorrido, o que via script pode ajudar a entender a origem do problema e até mesmo servir de conteúdo para um e-mail automaticamente enviado para o DBA.

Outro método que você pode utilizar é redirecionar a saida padrão de erros para /dev/null e utilizar os operadores ‘&&’ e ‘||’ do shell.

pg_dump > meu_banco.dump 2>/dev/null && echo "OK" || echo "ERRO"

No caso acima, se tudo ocorrer bem, ele ecoará “OK” do contrário “ERRO” será retornado.

Colocando tudo num script

Podemos utilizar os conceitos acima para criar um script que automatize este processo todo. Segue:

#!/bin/sh
###############################################
#
# Script de geração de dump full
#
# (c) 2006-2008 Dickson Guedes <guediz at gmail com>
#
###############################################

# Email DBA
CFG_EMAIL="dba@minhaempresa.com"

# Variaveis de mensagens
MSG_OK="Dump gerado com sucesso!"
MSG_ERRO="Dump gerado com erros!"
MSG_DATA=`date +"%Y-%m-%d"`

# Variaveis de caminhos dos utilitarios
PRG_PGDUMP="/usr/bin/pg_dump"

# Variaveis dos arquivos gerados
ARQ_DUMP="meu_banco"
ARQ_DUMP_OK="$ARQ_DUMP-$MSG_DATA.dump"
ARQ_DUMP_ERRO="$ARQ_DUMP-$MSG_DATA.erro"

###############################################

$PRG_PGDUMP >$ARQ_DUMP_OK 2>$ARQ_DUMP_ERRO && STATUS="SUCESSO" || STATUS="ERRO"

if [ "$STATUS" = "SUCESSO" ]; then
        echo "$MSG_OK"   | mail -s"$MSG_OK" $CFG_EMAIL
else
        echo "$MSG_ERRO" | mail -s"$MSG_ERRO" $CFG_EMAIL < $ARQ_DUMP_ERRO
fi

###############################################

DESAFIO: alterar o script acima adicionando a característica de passar o nome do banco de dados através de parâmetros de linha de comando.

Bom, é isso… “:)

Posted in postgresql | Etiquetado: , , , | 1 Comment »

Dúvidas frequentes sobre PostgreSQL

Posted by Guedes em março 13, 2008

Dúvidas frequentes sobre PostgreSQL É bastante comum volta e meia encontrar e-mails na lista pgbr-geral com perguntas que são recorrentes. Isso me deixa um tanto intrigado já que existe uma excelente FAQ, também traduzida pelo Euler para pt_BR.

Segue exemplo de algumas…

Como conectar o Delphi ao PostgreSQL?

Você pode optar por uma alternativa comercial como o PostgresDAC, ou pelo pgExpress Driver, por exemplo, ou ainda pode utilizar a ZEOS Lib que é a alternativa mais indicada em se tratando de software livre.

Quais ferramentas permitem a visualização dos relacionamentos das entidades do banco?

Longe de serem ferramentas de modelagem, elas permitem uma visualização dos relacionamentos existentes entre as entidades existentes em seu banco de dados. Podem ser bastante úteis como ferramentas de engenharia reversa. Vejamos:

DBVisualizer: possui uma versão paga e uma gratuita e é multi-plataforma. Entre outras funções, gera diagramas a partir do banco de dados, permitindo exportá-los para imagem ou imprimí-los. É feito em Java e aceita diversos outros bancos através dos drivers jdbc. A versão gratuita possui algumas limitações como o fato de não permitir execução de scripts SQL e ausência de auto-complementação, mas é uma excelente ferramenta.

Autodoc: é gratuito e escrito em perl. Gera informações de suas entidades em diversos formatos. Não possui interface gráfica. Contém um sistema de templates que permite você personalizar as saídas conforme suas necessidades, bem como gerar imagens gráficas de seus relacionamentos.

SQuirreL: é gratuito e escrito em java. É semelhante ao DBVisualizer e também permite gerar um diagrama por meio de engenharia reversa.

Como recuperar a instalação do PostgreSQL tendo apenas um backup da pasta dos dados?

Primeiramente você precisa saber qual era a versão de PostgreSQL instalado, qual o sistema de arquivos utilizado e qual o sistema operacional, pois são informações fundamentais para o sucesso dessa restauração. Em posse destas informações, instale o sistema operacional com a versão anteriormente utilizada, crie a partição para os dados com o mesmo sistema de arquivos anteriormente utilizado e instale a mesma versão de PostgreSQL que antes utilizava os dados que você tem em mãos.

Com esse ambiente montado você sobrescreve o cluster atual pela sua cópia. Esse tipo de alternativa é utilizada em casos emergenciais, tendo em vista que o ‘caminho feliz‘ é efetuar o dump via pg_dump, e restaurá-lo via pg_restore.

Bom, é isso! “:D

Posted in postgresql | Etiquetado: , , , | Leave a Comment »