Uma das ferramentas mais utilizadas na administração do PostgreSQL é o nosso bom e velho psql. Sua interface em modo texto permite a sua utilização local ou remota de maneira rápida e eficiente  nos presenteando com alguns recursos interessantes como por exemplo a complementação de código baseada em contexto (proporcionado pelo readline).

Outro recurso que utilizo é a personalização do prompt, e este é muito útil para quem está acostumado a conectar em vários servidores distintos, administrando várias bases de dados em cada um deles, pois ele pode lhe fornecer dados interessantes de uma forma simples e prática. Vou tentar exemplificar:

Imagine um cenário onde você administre 3 (três) servidores diferentes, cada um deles contendo algumas bases de dados, conforme a figura abaixo:

Você pode utilizar o script a seguir para definir o um prompt personalizado para cada servidor.

#!/bin/sh
########################################################
#
# Script inicializacao de parametros do psql
#
#
# 2007-2008 (c) Dickson Guedes <guediz at gmail dot com>
########################################################
ARG1=$1

PSQL_RC="$HOME/.psqlrc"

PROMPT_SRV01='%[%033[44;37;1m%](%`date +%H:%M:%S`) %n@%M:%>/%/ %[%033[0m%]\\n%x%# '
PROMPT_SRV02='%[%033[43;37;1m%](%`date +%H:%M:%S`) %n@%M:%>/%/ %[%033[0m%]\\n%x%# '
PROMPT_SRV03='%[%033[41;37;1m%](%`date +%H:%M:%S`) %n@%M:%>/%/ %[%033[0m%]\\n%x%# '
PROMPT_DEFAULT='%[%033[40;37;1m%](%`date +%H:%M:%S`) %n@%M:%>/%/ %[%033[0m%]\\n%x%# '

SERVIDOR=${ARG1:=srv01}

define_psqlrc() {
        echo "\set QUIET 1" > $PSQL_RC
        echo "\pset null '(null)'" >> $PSQL_RC
        echo "\set PROMPT1 '$1'" >> $PSQL_RC
        echo "\set PROMPT2 '| '" >> $PSQL_RC
        echo "\set HISTSIZE 5000" >> $PSQL_RC
        echo "\set HISTFILE ~/.psql_history- :DBNAME" >> $PSQL_RC
        echo '\\timing' >> $PSQL_RC
        echo "\set QUIET 0" >> $PSQL_RC
}

case $1 in
        srv01) define_psqlrc "$PROMPT_SRV01" ;;
        srv02) define_psqlrc "$PROMPT_SRV02" ;;
        srv03) define_psqlrc "$PROMPT_SRV03" ;;
            *) define_psqlrc "$PROMPT_DEFAULT" ;;
esac

psql -h $SERVIDOR
## FIM DO SCRIPT

Com esse script eu posso executá-lo e obter prompts diferenciados para cada servidor:

A data é apresentada através do uso da sequência de escape %`command`. Já as cores são mostradas através do uso da sequência de escape %[ ... %].

Outras sequências de escape e personalizações podem ser encontradas no manual do psql.

Bom, é isso!

]]> http://makeall.wordpress.com/2008/05/25/personalizando-o-psql/feed/ Guedes Personalizando o psql Personalizando o psql Personalizando o psql Personalizando o psql Personalizando o psql http://makeall.wordpress.com/2008/04/22/fisl-90-18-de-abril-3/ http://makeall.wordpress.com/2008/04/22/fisl-90-18-de-abril-3/#comments Tue, 22 Apr 2008 16:11:15 +0000 Guedes http://makeall.wordpress.com/?p=53

A última palestra que participei foi a do Diogo Biazus sobre replicação assincrona multi-mestre, expondo de maneira clara, profissional e bem-humorada, sua experiência com Bucardo

Apesar das limitações do Bucardo, na sua versão atual, para a sua proposta ele trabalha muito bem, e tem um futuro promissor. Já andei olhando seu código fonte, e fazendo alguns testes básicos e pretendo, seguindo as considerações expostas na palestra do Diogo, aplicá-lo em um ambiente com elevado número de transações por segundo e obviamente, os resultados serão postados aqui.

Em resumo, os contatos efetuados no FISL esse ano valeram a pena, bem como o elevado grau de informação, qualidade e profissionalismo dos palestrantes. Espero que o PgCon Brasil deste ano seja tão bom (ou melhor) quanto foram as palestras sobre o nosso elefantinho no FISL.

Bom é isso.

Hoje mudei um pouco a agenda, acabei visitando o estande do jCompany (community version) que foi lançado com licença GPLv3. Para quem não conhece a proposta do jCompany é de ser um framework para automatizar implementações em nível de Caso de Uso. Já o jCompany FS Framework é um software livre, totalmente escrito nas especificações Java EE 5 e que pode ser um fator importante para o o refatoramento de seu próprio código.
Essa versão SL criará uma nova ramificação do jCompany, onde a criatividade da comunidade permitirá um conjunto de inovações, as quais serão aos poucos estudadas testadas e validadas antes de entrarem no mundo corporativo.

Com essa nova visão, talvez em um futuro próximo quem sabe, ele poderá se aproximar ao que hoje é o AndroMDA que, infelizmente, não teve nenhuma palestra abordada esse ano.

Quem sabe ano que vem alguém não se empolgue e tome a iniciativa, não é mesmo Lino?

A Embrapa apresentou uma palestra sobre recuperação de informações em base de dados textuais, demonstrando sua experiência com o uso de ferramentas, tanto proprietárias quanto livres.
Ao iniciarem seus estudos com ferramentas livres várias alternativas foram utilizadas, inclusive o tsearch2 do nosso elefantinho foi testado, no entanto, para a necessidade deles de fazer indexação de textos, as alternativas eram mais complexas e exigiam o acoplamento de outras soluções mais especializadas.

Em uma visão geral da palestra foram apresentados os seguintes topicos.

Tecnicas de buscas textuais em banco de dados estudadas

Foram analisadas “Full Text Search” e “TSearch2″ (do nosso elefantinho), no entanto nenhuma delas satisfizeram as necessidades da Embrapa

Ferramentas de indexação textual

Foram analisadas SWISH-E, Lucene e OpenFTS, e delas a que mais se destacou foi a Lucene. principalmente pela compatibilidade com as linguagens de programação já utilizadas, que no caso seguiam a plataforma J2EE, e algo em PHP.

Resultados obtidos

O resultado pode ser visto no link: http://www.bdpa.cnptia.embrapa.br/busca.php e são bem expressivos em termos de tempo de resposta e sensibilidade ao contexto dos dados entrados.

Talvez esteja ai, uma extensão que nosso elefantinho posso começar a amadurecer, em minha singela opnião, acredito que um bom trabalho da comunidade poderia criar uma ferramenta que pudesse auxiliar nesse contexto, utilizando o PostgreSQL como servidor de aplicação.

Bom é isso..

O clima hoje não ajudou, aeroporto em POA fechado e acabei chegando atrasado ao FISL, perdendo assim a palestra do Fike. Imprevistos à parte, o clima esse ano no FISL está show de bola. A abertura dos estandes ao público e o ambiente universitário da PUCRS deram ao evento um clima bem descontraído e recheado de novidades.

Deu tempo de chegar para a palestra de Josh Berkus que foi bem interessante, as questões envolvendo segurança no PostgreSQL foram bem esplanadas. A diferença cultural não impediu que o publico participasse ativamente.

Logo em seguida, no mesmo auditório, David Fetter apresentou-nos sua palestra que exemplificou como utilizar o nosso Elefante como um Servidor de Aplicação. Dentre as inúmeras linguagens suportadas no PostgreSQL, ele focou seu exemplo em plperl/SQL frisando as questões de segurança, imutabilidade e clareza de código. Logo no início um pequeno trecho do Tropa de Elite que demonstra, segundo David Fetter, a maneira pela qual certamente não é a experiência que se tem ao se desenvolver algo utilizando PostgreSQL como um servidor de aplicações.

Acabei perdendo a palestra do Telles por problemas particulares, mas ouvi ótimos comentários.

Em tempo, o estande do elefantinho está show de bola, vale a pena conferir..

Bom é isso… as fotos vem em breve assim que eu baixá-las…

E amanhã começa o FISL 9.0, as expectativas são grandes, as palestras bem interessantes, e esse ano teremos uma participação forte do nosso amigo elefante (leia-se PostgreSQL).

Acabei montando minnha agenda no google calendar e publicando-a aqui. Todas as palestras do elefantinho estão lá bem como outras que tenho interesse, monte a sua também, imprime-a e leve com você no FISL, esteja preparado pois eventuais mudanças de horário ocorrem e não esqueça de visitar nosso estande.

No decorrer do evento irei postar aqui no blog informações e imagens para os colegas que não puderem comparecer de alguma forma ou de outra ao evento.

E para ajudar o povo que está indo para lá alguns links:

Mapa de localização do evento

Mapa de localização do estande do PostgreSQL (indicador azul)

Palestras sobre PostgreSQL e Banco de dados

Minha agenda do FISL 9.0 com as palestras do PostgreSQL e outras

Quadro de palestras do FISL 9.0

Bom, é isso! Nos vemos por lá… “:D

Caros, hoje pretendo ser o mais breve possível apresentando uma dica rápida. Pois bem, apesar de existirem algumas ferramentas gráficas como o Aqua Studio, DbVisualizer e o próprio pgAdminIII, o meu fiel companheiro de todos os dias acaba sendo o bom e velho psql. Leve, simples e bastante completo ele me proporciona agilidade em muitas das minhas tarefas diárias.

Nessas últimas versões ele vem recebendo algumas características novas. Uma delas que podemos esperar para a versão 8.4, por exemplo, é uma melhoria do comando “\l+” que, nessa versão, mostra também os tamanhos que os bancos de dados ocupam:

analise=# \l+
                                                               List of databases
   Name    |   Owner   | Encoding |                    Access Privileges                     |  Size   | Tablespace |        Description
-----------+-----------+----------+----------------------------------------------------------+---------+------------+---------------------------
 analise    | postgres  | UTF8     | {sademo=CTc/postgres,postgres=CTc/postgres,=Tc/postgres} | 151 MB  | pg_default |
 bench     | postgres  | UTF8     |                                                          | 710 MB  | pg_default |
 postgres  | postgres  | UTF8     |                                                          | 4215 kB | pg_default |
 livraria   | sasebo    | UTF8     |                                                          | 4136 kB | pg_default |
 template0 | postgres  | UTF8     | {=c/postgres,postgres=CTc/postgres}                      | 4136 kB | pg_default |
 template1 | postgres  | UTF8     | {postgres=CTc/postgres,=c/postgres}                      | 4136 kB | pg_default | default template database

No entanto, para o comando “\d+”, não foi implementada a mesma idéia, ou seja, ele não lista o tamanho dos objetos (visões, tabelas, sequências, indices) e por isso eu acabei criando o patch abaixo que, uma vez aplicado na versão última versão do PostgreSQL no CVS, habilita essa característica no psql:

Index: describe.c
===================================================================
RCS file: /projects/cvsroot/pgsql/src/bin/psql/describe.c,v
retrieving revision 1.166
diff -c -r1.166 describe.c
*** describe.c	30 Mar 2008 18:10:20 -0000	1.166
--- describe.c	11 Apr 2008 04:59:56 -0000
***************
*** 1766,1775 ****
--- 1766,1781 ----
  						  gettext_noop("Table"));

  	if (verbose)
+ 	{
  		appendPQExpBuffer(&buf,
  			  ",\n  pg_catalog.obj_description(c.oid, 'pg_class') as \"%s\"",
  						  gettext_noop("Description"));

+ 		appendPQExpBuffer(&buf,
+ 			  ",\n  pg_catalog.pg_size_pretty(pg_catalog.pg_relation_size(c.oid)) as \"%s\"",
+ 					  	  gettext_noop("Size"));
+ 	}
+
  	appendPQExpBuffer(&buf,
  					  "\nFROM pg_catalog.pg_class c"
  					"\n     JOIN pg_catalog.pg_roles r ON r.oid = c.relowner"
***************
*** 1809,1816 ****
  	processSQLNamePattern(pset.db, &buf, pattern, true, false,
  						  "n.nspname", "c.relname", NULL,
  						  "pg_catalog.pg_table_is_visible(c.oid)");
!
! 	appendPQExpBuffer(&buf, "ORDER BY 1,2;");

  	res = PSQLexec(buf.data, false);
  	termPQExpBuffer(&buf);
--- 1815,1825 ----
  	processSQLNamePattern(pset.db, &buf, pattern, true, false,
  						  "n.nspname", "c.relname", NULL,
  						  "pg_catalog.pg_table_is_visible(c.oid)");
!
! 	if (verbose)
! 		appendPQExpBuffer(&buf, "ORDER BY 1, pg_catalog.pg_relation_size(c.oid) DESC, 2;");
! 	else
! 		appendPQExpBuffer(&buf, "ORDER BY 1,2;");

  	res = PSQLexec(buf.data, false);
  	termPQExpBuffer(&buf);

O que eu faço é mostrar uma coluna a mais (”Size”), e ordenar a saída por Esquema, Tamanho (decrescente) e Nome do objeto. A saída fica algo assim:

analise=# \d+
                                      List of relations
 Schema  |                Name                | Type  |   Owner    | Description |    Size
---------+------------------------------------+-------+------------+-------------+------------
 teste   | tb_cliente                         | table | sa_analiseq   | Cliente     | 8192 bytes
 teste   | tb_compra                          | table | sa_analise   | Compra      | 8192 bytes
 teste   | tb_item_compra                     | table | sa_analise   | ItemCompra  | 8192 bytes
 teste   | tb_produto                         | table | sa_analise   | Produto     | 8192 bytes
 financ | tb_caixa                           | table | sa_analise   | Caixa       | 517 MB
 financ | tb_banco                           | table | sa_analise   | Banco       | 80 MB
 generic | tb_cliente                         | table | sa_analise | Cliente     | 250 MB
 generic | tb_pessoa                          | table | sa_analise   | Pessoa      | 140 MB

Bom, é isso! “:D

A semana foi corrida, e o final de semana foi totalmente utilizado para descanso e lazer. Mas a vontade de escrever é maior, e cá estou novamente pronto para mais um post. A idéia hoje era falar sobre scripts SQL, então imaginei algo diferente, e pensei em mostrar como fazer um script interativo no PostgreSQL 8.3, associando o seu uso a um cenário hipotético. Vejamos…

Em um universo ideal, é muito comum existir um banco de dados de desenvolvimento, um de testes, um de homologação e um de produção. Neste cenário, imagine que seu Analista de Testes precise testar uma nova funcionalidade do sistema relacionada ao módulo de compras, e que para isso constantemente você tenha que aplicar a carga de testes desse módulo no banco de dados de teste, não é de se estranhar que você possua uma carga pronta (é o mínimo que você deveria ter).

Veja a seguir o script simplificado que representa esse cenário:

CREATE TABLE tb_cliente (
     nr_documento numeric(14,0) NOT NULL,
     nm_cliente character varying(60)
);
ALTER TABLE blog.tb_cliente OWNER TO postgres;

CREATE TABLE tb_compra (
     nr_nota_fiscal numeric(15,0) NOT NULL,
     dt_compra date,
     nr_documento_cliente numeric(14,0)
);
ALTER TABLE blog.tb_compra OWNER TO postgres;

CREATE TABLE tb_item_compra (
     nr_nota_fiscal numeric(15,0) NOT NULL,
     nr_referencia integer NOT NULL,
     qt_item smallint DEFAULT 1
);
ALTER TABLE blog.tb_item_compra OWNER TO postgres;

CREATE TABLE tb_produto (
     nr_referencia integer NOT NULL,
     ds_produto character varying(60) NOT NULL,
     vl_venda numeric(15,2)
);
ALTER TABLE blog.tb_produto OWNER TO postgres;

CREATE SEQUENCE tb_produto_nr_referencia_seq
     INCREMENT BY 1
     NO MAXVALUE
     NO MINVALUE
     CACHE 1;
ALTER TABLE blog.tb_produto_nr_referencia_seq OWNER TO postgres;

ALTER SEQUENCE tb_produto_nr_referencia_seq OWNED BY tb_produto.nr_referencia
ALTER TABLE tb_produto ALTER COLUMN nr_referencia SET DEFAULT nextval('tb_produto_nr_referencia_seq'::regclass);

ALTER TABLE ONLY tb_compra
     ADD CONSTRAINT pk_compra PRIMARY KEY (nr_nota_fiscal);
ALTER TABLE ONLY tb_item_compra
     ADD CONSTRAINT pk_item_compra PRIMARY KEY (nr_nota_fiscal, nr_referencia);
ALTER TABLE ONLY tb_cliente
     ADD CONSTRAINT pk_pessoa PRIMARY KEY (nr_documento);
ALTER TABLE ONLY tb_produt
     ADD CONSTRAINT pk_produto PRIMARY KEY (nr_referencia);

ALTER TABLE ONLY tb_compra
     ADD CONSTRAINT fk_cliente_compra_01 FOREIGN KEY (nr_documento_cliente) REFERENCES tb_cliente(nr_documento);
ALTER TABLE ONLY tb_item_compra
     ADD CONSTRAINT fk_compra_item_compra_01 FOREIGN KEY (nr_nota_fiscal) REFERENCES tb_compra(nr_nota_fiscal);
ALTER TABLE ONLY tb_item_compr
     ADD CONSTRAINT fk_produto_item_compra_01 FOREIGN KEY (nr_referencia) REFERENCES tb_produto(nr_referencia);

Esse é o conteúdo simplificado da entidade cliente no banco de dados de teste:

 nr_documento |        nm_cliente
--------------+---------------------------
74727756632 | Marta Antonia
56548986527 | Antonia Josefina
47040567970 | Adamantina Pereira
24348435149 | Carlos Augusto
80987468692 | José Silveira
56096344407 | Maria Eleontina de Castro
79056669606 | José da Silva Sauro
31887461081 | Ribamar de Castr
45792555043 | Manoel Bandeira

Esse é o conteudo simplificado da entidade produto no banco de dados de teste:

 nr_referencia |    ds_produto     | vl_venda
---------------+-------------------+----------
1 | Sapato Velho      |    15.00
2 | Sapato Novo       |    25.00
3 | Blusa Velha       |    35.00
4 | Blusa Nova        |    45.00
5 | Calça Jeans Velha |    29.50
6 | Calça Jeans Nova  |    49.50
7 | Peruca Masculina  |   439.9
8 | Camisola          |    19.50

E este é o Script de Carga de Teste para as entidades tb_compra e tb_item_compra:

postgres@banco $ cat ~/scripts/carga_compra_teste.sql
/***************************************************
*
* Script de geração de carga
* Modulo de Compras - Banco de dados de Teste
*
* (c) 2007 Dickson Guedes <guediz at gmail dot com>
*
****************************************************/

INSERT INTO tb_compra (nr_nota_fiscal, dt_compra, nr_documento_cliente
     VALUES (1234567890, now(), 56473847366);

INSERT INTO tb_item_compra (nr_nota_fiscal, nr_referencia, qt_item)
     VALUES (1234567890, 6,  2);
INSERT INTO tb_item_compra (nr_nota_fiscal, nr_referencia, qt_item)
     VALUES (1234567890, 4,  1);
INSERT INTO tb_item_compra (nr_nota_fiscal, nr_referencia, qt_item)
     VALUES (1234567890, 3, 15);
INSERT INTO tb_item_compra (nr_nota_fiscal, nr_referencia, qt_item
     VALUES (1234567890, 2,  2);

INSERT INTO tb_compra (nr_nota_fiscal, dt_compra, nr_documento_cliente
     VALUES (1122334455, now(), 56096344407);

INSERT INTO tb_item_compra (nr_nota_fiscal, nr_referencia, qt_item)
     VALUES (1122334455, 6,  2);
INSERT INTO tb_item_compra (nr_nota_fiscal, nr_referencia, qt_item)
     VALUES (1122334455, 4,  1);
INSERT INTO tb_item_compra (nr_nota_fiscal, nr_referencia, qt_item)
     VALUES (1122334455, 3, 15);
INSERT INTO tb_item_compra (nr_nota_fiscal, nr_referencia, qt_item
     VALUES (1122334455, 2,  2);

E para executá-lo e utilizo o utilitário psql:

postgresql@banco $ psql bdtesteWelcome to psql 8.4devel, the PostgreSQL interactive terminal.

Type:  \copyright for distribution terms
     \h for help with SQL commands
     \? for help with psql commands
     \g or terminate with semicolon to execute quer
     \q to quit

postgres=# \i ~/scripts/carga_compra_teste.sql

E se eu quisesse tornar esse script interativo?

O utilitário psql além de aceitar instruções SQL, possui um conjunto de instrucoes proprias que nos permitem extenter suas funcionalidades. Utilizaremos duas delas: \echo, que permite enviar um texto para a console do psql e \prompt (a partir da versão 8.3 do PostgreSQL) que permite receber um dado da entrada e salvar um uma variável.

Nosso script acima poderia ficar assim:

/***************************************************
*
* Script de geração de carga
* Modulo de Compras - Banco de dados de Teste
*
* (c) 2007 Dickson Guedes <guediz at gmail dot com>
*
****************************************************/

\echo """"""""""""""""""""""""""""""""""""""""""
\echo " Gerando carga para o ambiente: TESTE   "
\echo "                                        "
\echo " Cenário: Prestacoes de compra a prazo  "
\echo "                                        "
\echo """"""""""""""""""""""""""""""""""""""""""
\echo
\echo Continuar..: Enter
\echo Cancelar...: Ctrl+C

\prompt continua
\unset continuar

\echo
SELECT nr_documento || ' -> ' || nm_cliente AS "Lista de Clientes" FROM tb_cliente;
\echo
\prompt 'Informe um dos números de CPFs acima.: ' v_nr_document
\prompt 'Informe o número da nota fiscal......: ' v_nr_nota_fiscal

\echo '* Inserindo compra para o cliente:' :v_nr_documento 'com número de nota fiscal:' :v_nr_nota_fiscal

INSERT INTO tb_compra (nr_nota_fiscal, dt_compra, nr_documento_cliente) VALUE
     (:v_nr_nota_fiscal, now(), :v_nr_documento);

INSERT INTO tb_item_compra (nr_nota_fiscal, nr_referencia, qt_item) VALUES
     (:v_nr_nota_fiscal, 2, ((RANDOM()*5)+1)::int2),
     (:v_nr_nota_fiscal, 4, ((RANDOM()*5)+1)::int2),
     (:v_nr_nota_fiscal, 7, ((RANDOM()*5)+1)::int2),
     (:v_nr_nota_fiscal, 5, ((RANDOM()*5)+1)::int2);

\echo "* Script finalizado!"

E para executá-lo e utilizo também o utilitário psql:

postgresql@banco $ psql bdtesteWelcome to psql 8.4devel, the PostgreSQL interactive terminal.

Type:  \copyright for distribution terms
\h for help with SQL commands
\? for help with psql commands
\g or terminate with semicolon to execute quer
\q to quit

postgres=# \i ~/scripts/carga_compra_teste.sql

DICA 1: quando usar o \prompt você pode usar 2 (dois) argumentos: um texto explicativo seguido do nome da variável que você deseja armazenar o valor recebido.
DICA 2: os valores das variáveis são recuperados utilizando-se o dois pontos (”:”) precedendo o nome da variável que se deseja ler o valor, como por exemplo \echo ‘Valor da variavel é’ :variavel_qualquer.

DESAFIO 1: Tente alterar o script acima para que os produtos também sejam aleatórios, ou seja, cada vez que o script for executado ele gere uma carga diferente.

DESAFIO 2: Como você trataria o problema de um erro de digitação ou problema de violação de chaves? Você poderia utilizar transações?

Em um ambiente corporativo com aplicações de missão crítica, qualquer instante de instabilidade pode causar um grande prejuízo para seu cliente, e conseqüentemente para sua empresa. Neste universo, onde todas as camadas de infra-estrutura que dão suporte ao funcionamento de suas aplicações precisam estar altamente-disponíveis, faz-se necessário tomar medidas preventivas a fim de identificar, pro-ativamente, qualquer incidente que pode acarretar em um grande problema.

Neste cenário, o papel do DBA é muito importante, pois ele pode identificar, já na camada de Banco de Dados, possíveis candidatos a problemas futuros. No entanto, ele precisa de ferramentas de apoio para tal tarefa, a fim de tornar seu trabalho produtivo e pró-ativo e não reativo, como em muitas empresas.

Sendo assim, gostaria de falar hoje sobre o nosso amigo ptop, que é uma espécie de ‘top’ para o PostgreSQL. Inspirado no top dos sistemas UNIX-like, ele permite:

• Visualizar a instrução SQL sendo executada por um processo;
• Visualizar o plano de execução de um SELECT rodando no momento;
• Visualizar os locks de um determinado processo;
• Visualizar as estatísticas das tabelas de usuário;
• Visualizar as estatísticas dos índices de usuário;

Obtendo e Instalando

A última versão estável do ptop é a 3.6.1 mas já existem versões beta disponíveis que podem ser baixadas e testadas. No nosso caso utilizaremos a última versão estável, fazendo o download e salvando em um diretório temporário, como por exemplo: /tmp.

Vamos supor que você deseja monitorar via ptop um ambiente de desenvolvimento com as seguintes características:

Nome do bando de dados: desenvolvimento
Porta: 5432
Usuário: monitor
Senha: m0n1t0r

(Para esse exemplo foi criado um usuário monitor no PostgreSQL, sem qualquer privilégio a mais, apenas de conexão ao banco)

Salve o arquivo baixado no servidor que deseja monitorar e siga os passos:

# Descompacte o arquivo ...
tar zxvf ptop-3.6.1.tar.gz

# Acesse o diretorio criado
cd ptop-3.6.1/

# Leia os arquivos README e INSTALL
# (sim eles não têm esses nomes à toa... ":D )
less README
less INSTALL

# Configure e compile o codigo
./configure && make

# Após compilar um arquivo executável sera criado
ls -la ptop
-rwxr-xr-x 1 guedes guedes 140282 2008-04-01 20:48 ptop

# Execute-o com a opção --help
./ptop --help
./ptop: invalid option -- -
Top version 3.6.1
Usage: ptop [-ISTWbcinqu] [-x x] [-s x] [-o field] [-z username]
              [-p PORT] [-U USER] [-d DBNAME] [-h HOSTNAME] [number]

Visão geral do ptop

Para executar o ptop use:

./ptop -U monitor -d desenvolvimento -h localhost -W

Será solicitada a senha do usuário ‘monitor‘, informe-a corretamente. A tela que surge é semelhante a esta:

Com o ptop sendo executado, é possível ver uma série de informações úteis sobre o servidor e os processos do PostgreSQL. A semelhança do mesmo com o utilitário top do UNIX é visível e não é mera coincidência…

Principais comandos do ptop e suas telas

Obtendo ajuda no ptop: pressione ‘?’ ou ‘h’

Obtendo o plano de execução de um processo: pressione ‘E’ (maiúsculo) e digite o número de um determinado processo (PID) para visualizar o plano de execução do mesmo.

Obtendo as estatísticas das tabelas em uso: pressione ‘R’ (maiúsculo)

Obtendo as estatísticas dos índices em uso: pressione ‘X’ (maiúsculo)

Visualizando os locks de um determinado processo: pressione ‘L’ (maiúsculo) e digite o número do processo (PID) que deseja visualizar

DESAFIO 1: tente alterar a ordem de classificação dos processos (por cpu, tempo de execução ou utilização de recursos, por exemplo).
DESAFIO 2: tente alterar o número de processos a serem mostrados.

Bom, é isso! “:D

Depois de muito trabalho, finalmente o Planeta PostgreSQL foi migrado para um novo banco. Os dados, que antes se encontravam em DB2, agora estão rodando perfeitamente em SQLite hospedado em servidores gentilmente cedidos a nós pela Sony, Tokyo, Japão.

Para que você saiba, passo a passo, como tudo foi feito, disponibilizamos o artigo neste link. Bem como informações de infra-estrutura aqui neste outro.