ImaginarTI

CLOB e ORA-06502 - Por que e como corrigir

2011-07-28T13:23:00.000-03:00

Ontem eu estava depurando uma procedure Oracle que faz a importação de dados de um sistema para outro. Essa procedure de importação gera log de tudo: dados importados, dados rejeitados, motivo de rejeição e etc. O log é todo armazenado em uma variável CLOB, que ao final do processo é anexada ao registro que armazena a execução da importação - foi executado na data tal, e o resultado foi tal.

Ocorre que com o aumento da massa de dados a ser importada, começaram a aparecer erros ORA-06502 (PL/SQL: numeric or value error). Com a ajuda do PL/SQL Developer, consegui identificar que a exceção era gerada em uma linha que concatenava alguns valores na variável CLOB. Eu demorei algumas horas até me lembrar que uu já tinha visto esse erro devido à conversão implícita de string em número.

Nessas horas foram algumas pesquisas na internet, até que achei um blog que me deu algumas dicas e a memória clareou (vou ficar devendo o crédito pois perdi o endereço do blog original).

O fato é que na conversão implícita, o Oracle tenta converter tudo para NÚMERO. Isso é porque as operações com números (geralmente comparações, originadas de cláusulas WHERE) são muito mais rápidas que comparações de string. Só que apesar de mais rápido, é uma conversão menos segura, pois pode não funcionar em todos os casos. No nosso caso de CONCATENAÇÃO (e não de comparação), o Oracle tenta converter tudo para varchar, e nisso dá erro.

Vamos a comprovação: Um laço que a cada volta, concatena um número em um CLOB.

declare
    l_clob clob;
   
begin

    for i in 1..50000
    loop
        l_clob   := l_clob || 1;
        -- conversão implícita de número em varchar
        -- força a conversão do blob em varchar também.
    end loop;
    dbms_output.put_line (length(l_clob));

exception
    when others then
          dbms_output.put_line ('error: ' || sqlerrm);
          dbms_output.put_line (length(l_clob));
end;

Internamente o oracle converte esse CLOB em varchar, concatena com o 1 (também internamente já convertido em varchar), e armazena de volta na variável CLOB. Só que conforme a variável CLOB vai crescendo, chega um momento que fica maior que 32768 bytes (o limite de tamanho de varchar). Nessa hora, gera a exceção.

Agora veja o exemplo abaixo, quase igual ao anterior. A diferença é que agora a concatenação é de uma string em um CLOB. Nesse caso o Oracle não faz a conversão do CLOB em varchar, e portanto não viola o limite do varchar. Logo, não dá erro!

declare
    l_clob clob;
   
begin

    for i in 1..50000
    loop
        l_clob := l_clob || to_char(1);
        -- sem conversão implícita de número (ou datas),
        -- a operação é entre varchar e clob. Neste caso,
        -- não há conversão do clob em varchar.
    end loop;
    dbms_output.put_line (length(l_clob));

exception
    when others then
          dbms_output.put_line ('error: ' || sqlerrm);
          dbms_output.put_line (length(l_clob));
end;

É isso.
Espero que sirva para ajudar mais alguém por aí.

Abraços e até a próxima!

ASP.NET MVC3 com Assemblies Privados

2011-07-22T14:13:00.001-03:00

Esta semana eu precisei colocar um site novo no ar, no espaço de hospedagem da ImaginarTI. Curiosamente foi o primeiro site em ASP.NET MVC3 que vai para a nossa hospedagem - os demais ficaram hospedados diretamente nos clientes. O nosso provedor de hospedagem afirma que suporta MVC3, então achei que seria 100% transparente. Não foi bem assim...

O fato é que após subir os arquivos, começaram a aparecer um monte de problemas. Modificamos o web.config para exibir os erros (só para debug do deloy mesmo) e vimos que eram assemblies faltando. Como assim faltando?

Entrei em contato com o suporte da hospedagem e eles disseram que suportam o MVC 3, mas que eu tenho que colocar as DLL's no BIN. Ora, isso não é exatamente "suportar" MVC3, né? Me senti enganado (menos um ponto para esses caras), mas resolvi não brigar dessas vez. Bola para frente.

Como resolver?
Bem, o projeto (no VS2010) tinha sido criado com o template de projeto do próprio MVC, então todas as referências já estavam setadas corretamente. Bastou eu alterar algumas referências, mudando o COPY LOCAL para true, e acrescentar outras referências (também com COPY LOCAL true) e tudo voltou a funcionar.

Não cheguei nem a procurar na internet, mas me lembro que o Scott Gu já tinha falado sobre isso. De qualquer forma, o que resolveu o meu caso foi:

Mudar o COPY LOCAL para True

System.Web.Helpers
System.Web.Mvc
System.Web.WebPages

Novas referências

Microsoft.Web.Infrastructure
System.Web.WebPages.Razor
System.Web.WebPages.Deployment
System.Web.Razor

Tomara que ajude mais alguém por aí.

Até a próxima!

ASP x Asp.Net -- como explicar para leigos

2011-07-04T14:44:00.001-03:00

Hoje um amigo aqui do trabalho, o Rodrigo Diniz (responsável pelo ExtJS Extender Controls) tentava me explicar como tentar fazer um advogado entender a diferença entre as tecnologias ASP (Asp 3 ou Asp "clássico") e Asp.Net. O advogado em questão era um outro funcionário que validava uma feature do sistema jurídico.

Conta o Diniz que argumentou o seguinte:

Escrever em Asp é como escrever em Latim, enquanto Asp.Net é como escrever em Portugês. Dá para dizer a mesma coisa, mas um é mais antigo, menos preciso e já não há tanta gente que consegue entender.

Exageros a parte, até concordei com a idéia.
E você, o que achou?

LiveMeeting no Ubuntu

2011-03-27T12:59:00.000-03:00

Aconteceu ontem o MVC Summit 2011, desta vez totalmente web, transmitido através do LiveMeeting.

Mesmo tendo a plataforma da Microsoft como a minha principal (C# Asp.Net), meu desktop roda Linux Ubuntu e, claro, não há um cliente nativo do LiveMeeting para o Ubuntu. Restou então a versão webhosted do client, que é baseado em Java.

Claro que não ia ser simples assim, afinal a Canonical resolveu trocar o Java da Sun (agora Oracle), pelo Open Java, com o argumento que é a mesma coisa, só que OpenSource. Vá lá, ele até é bem bonzinho sim, mas o webclient do LiveMeeting não quis rodar com ele de jeito nenhum.

Desconfiei que fosse esse o problema, e resolvi trocar a OpenJRE pela da Sun mesmo. Uma rápida "Googlada", e encontrei como substituir um pelo outro. Se alguém tiver dificuldade de achar, comenta aí, que eu passo o caminho das pedras.

OpenJRE removido, Sun JRE instalado, vamos aos testes. A Microsoft tem disponível uma página de testes de reuniões LiveMeeting. Infelizmente essa reunião de testes não tem áudio configurado, mas pelo menos serve para testar o vídeo. Só que mesmo com o JRE da Sun, o troço ainda não funcionava.

Mais uma procurada, dessa vez bem demorada, e acabei encontrando um blog que divulgava uma dica de um brasileiro, que ensinava como acertar. O link que eu achei foi este aqui, o crédito original é do @CiroRodrigues e o resumo da história é esse:

Vá no menu System > Preferences > Sun Java 6 Plugin Control Panel.
Vá na aba "Advanced", abra o item "Security", abra "Mixed Code (sandboxed vs. trusted) security verification", e selecione a opção "Enable - hide warning and run with protections".

É isso aí, espero que ajude.

Abraços e até a próxima.
@leozacche

Teletransporte

2010-09-23T10:20:00.000-03:00

Quem nunca desejou ter a sua própria máquina de tele-transporte, que atire a primeira pedra. Eu sempre quis ter uma, mesmo antes de assistir ao filme "A Mosca" (aquele com o Jeff Goldblum).

É, meu caro, parece que não estamos sozinhos. A Sony, através do PlayStation Home, realizou o nosso sonho. Virtualmente, pelo menos.

Agora é só torcer para não haver colisão de pacotes, congestionamento de tráfego, nem faltar luz no meio do caminho. Veja o trailer e me diga o que achou.

abs

LZ

Dicas para SQL Dinâmico - Apóstrofos

2010-08-26T18:48:00.011-03:00

Olá pessoal.

A dica de hoje vai para quem precisa construir comandos SQL dinâmicos, seja dentro de stored procedures ou diretamente no código da sua linguagem de preferência. Vou usar Oracle para o exemplos, mas o conceito também se aplica ao SQL Server. Para deixar os posts menores, vou fazer cada dica um post diferente.

Apóstrofo (ou aspas simples)

Todo mundo sabe que, em uma instrução SQL, as strings são delimitadas por apóstrofo (que alguns chamam de aspas simples). Assim:

create table tab_a (col1 varchar2(100) not null, col2 varchar2(100) not null);
declare
    minha_string varchar2(1000);
begin
    minha_string := 'isso é uma string';
end;
/

Muito bem. Mas e se a string em questão for uma instrução SQL? Ela, por natureza é uma linha de texto e que pode ter uma string dentro. Imagine o comando:

insert into tab_A (col1, col2) values ('valor 1', 'valor 2');

Se esse comando for uma instrução SQL dinâmica, você teria algo como isso:

declare
    meu_sql varchar2(1000);
begin
    meu_sql := 'insert into tab_A (col1, col2) values (''valor 1'', ''valor 2'')';
end;
/

Repare que para reproduzir um apóstro dentro de uma string, eu tenho que duplicá-lo, porque ele é um caracter especial (delimitador de string). Se colocasse sem duplicar, o compilador ia acusar erro, achando que haveria strings em sequencia, sem concatenar, nem nada.

Agora vamos adicionar um pouco de complexidade ao exemplo. Vou transformar esse pequeno bloco anônimo numa stored procedure com dois parâmetros do tipo string, que serão usados para preencher col1 e col2.

create or replace procedure proc_exemplo (pCol1 in varchar2, pCol2 in varchar2) as
    vSQL varchar2(1000);
begin
    vSQL := 'insert into tab_A (col1, col2) values (''' || pCol1 || ''', ''' || pCol2 || ''')';
    execute immediate vSQL;
end;
/

Sabemos que usar variáveis de ligação é muito mais eficiente, mas resolvi adotar esta estratéria
"ruim" apenas como exemplo de manipulação de strings. Outro dia eu falo sobre binding vars.

Repare como os diversos apóstrofos colados começam a prejudicar a leitura do código da proc. E é apenas uma linha de código!!! Imagine um insert imenso com muitas colunas string, o comando quebrado em várias linhas... Começa a ficar realmente ruim.

Para deixar o código mais limpo (facilitar a leitura), eu vou substituir cada apóstrofo duplicado (aqueles de dentro da string, e somente esses!) por uma aspa comum (ou dupla, se preferir). Percebe que um apóstrofo duplicado ('') não é a mesma coisa que uma aspa ("). São caracteres diferentes!!!.

create or replace procedure proc_exemplo (pCol1 in varchar2, pCol2 in varchar2) as
    vSQL varchar2(1000);
begin
    vSQL := 'insert into tab_A (col1, col2) values ("' || pCol1 || '", "' || pCol2 || '")';
    execute immediate vSQL;
end;
/

Mais fácil de ler, não?
Mais fácil para identificar onde começa e onde termina cada string (cada "pedaço" do comando SQL).

Só que se você executar esta proc, vai dar erro. Isto porque as aspas não são aceitas (em PL/SQL nem T-SQL) como delimitadores de string.

A correção é bem simples: Pode usar aspas à vontade dentro da sua string e, no último momento antes de executar o comando, você converte todas as aspas para apóstrofos duplos.

create or replace procedure proc_exemplo (pCol1 in varchar2, pCol2 in varchar2) as
    vSQL varchar2(1000);
begin

    -- preparando o comando SQL
    vSQL := 'insert into tab_A (col1, col2) values ("' || pCol1 || '", "' || pCol2 || '")';

    -- fazendo os ultimos ajustes antes de executar
    vSQL := replace(vSQL, '"', '''');
    execute immediate vSQL;

end;
/

A linha do replace é a única que você terá que manter bagunçada (vários caracteres apóstrofo), mas como é uma linha só, que fica só no final do bloco de código, dá para conviver.

Há uma restrição que você não pode usar aspas para nenhum outro fim, dentro do seu comando SQL. Se você puder atender este requisito, está feito. E eu particularmente não considero uma coisa muito esperta usar aspas (") nos nomes dos objetos Oracle. Serve só para dar dor-de-cabeça, mas isso também é papo para outro dia.

É isso pessoal.
Espero que sirva de ajuda para alguém por aí.

Abraços,

LZ

Parâmetro opcional em stored procedure (mão na roda)

2010-08-19T14:54:00.015-03:00

Hoje vou dar uma dica para facilitar o trabalho de debug de uma stored procedure. Vai em Oracle, porque é o que eu tenho na mão para mostrar (sem falar da minha preferência, claro).

Frequentemente, quando escrevo uma nova stored procedure (ou altero uma existente), eu acrecento um parâmetro adicional, opcional, que indica se a proc deve rodar em "modo debug". Coloco no final da lista de parâmetros (geralmente é o último) e como opcional, porque assim eu não preciso alterar nenhum programa que use esta proc, e ainda tenho a flexibilidade de usar o parâmetro.

"Mas o que faz este parâmetro?" - perguntarão alguns. Eu já disse! Indica se a proc deve rodar em modo debug.

"Modo debug?"

É. É um apelido, uma forma sofisticada de dizer que a proc vai fazer algum trabalho extra. No caso, o trabalho de coletar informações sobre a sua própria execução.
Essa coleta pode ser, exibir o valor de uma variável, indicar se entrou em um IF (ou se entrou no ELSE), exibir a quantide de registros lidos, etc...

Vamos ao exemplo prático:

(lembrando, é ORACLE e vc pode colar os comandos direto no SQL*Plus)

Imagine uma proc spProc1, que serve apenas para inserir descrições em uma tabela TabA, se não existirem, e retornar o Id gerado. Assim:

create table TabA (
    Id             number        not null,
    Descricao      varchar2(50)  not null,
    DataCriacao    date          not null
);

alter table TabA add constraint PK_TabA primary key (Id);
alter table TabA add constraint UK_TabA_Descricao unique (Descricao);

create or replace procedure spProc1(pDescricao in varchar2, pId out number) as
    vQtd number;
begin

    select count(1) into vQtd from TabA where Descricao = pDescricao;

    if (vQtd = 0) then

        select nvl(max(Id),0)+1 into pId from TabA;

        insert into TabA (Id, Descricao, DataCriacao)
        values (pId, pDescricao, sysdate);

    end if;

end;
/
show errors
    

Vamos inserir uns dados para ver que está tudo funcionando direito...

variable novo_id number

exec spProc1('Leonardo', :novo_id);
print novo_id;

exec spProc1('ImaginarTI', :novo_id);
print novo_id;

exec spProc1('Zacche', :novo_id);
print novo_id;

select * from TabA;
    

Agora vamos supor que você descobriu que, se ao chamar a proc, fornecer uma descrição que já exista na tabela, o ID retornado é nulo.

exec spProc1('Mais um', :novo_id);
print novo_id;

exec spProc1('Mais um', :novo_id);
print novo_id;
    

Depurar esta procedure é fácil porque é curta. Uma procedure longa, seria mais complicado. Para facilitar, vou colocar algumas linhas de DEBUG na procedure.

create or replace procedure spProc1(pDescricao in varchar2, pId out number) as
    vQtd number;
begin

    select count(1) into vQtd from TabA where Descricao = pDescricao;
    dbms_output.put_line(vQtd || ' registro(s) encontrado(s).');


    if (vQtd = 0) then

        select nvl(max(Id),0)+1 into pId from TabA;
        dbms_output.put_line('O Id gerado foi ' || pID);

        insert into TabA (Id, Descricao, DataCriacao)
        values (pId, pDescricao, sysdate);

    end if;

end;
/
show errors

Vamos testar novamente, com um novo valor, e depois repetí-lo.

set serveroutput on 100000
exec spProc1('Teste dois', :novo_id);
print novo_id;

exec spProc1('Teste dois', :novo_id);
print novo_id;

Descobrimos que não está entrando no IF. Vamos escrever um ELSE.

create or replace procedure spProc1(pDescricao in varchar2, pId out number) as
    vQtd number;
begin

    select count(1) into vQtd from TabA where Descricao = pDescricao;
    dbms_output.put_line(vQtd || ' registro(s) encontrado(s).');


    if (vQtd = 0) then

        select nvl(max(Id),0)+1 into pId from TabA;
        dbms_output.put_line('O Id gerado foi ' || pID);

        insert into TabA (Id, Descricao, DataCriacao)
        values (pId, pDescricao, sysdate);

    else

        select Id into pId from TabA where Descricao = pDescricao;
        dbms_output.put_line('O Id encontrado foi ' || pID);
        
    end if;

end;
/
show errors


exec spProc1('Teste tres', :novo_id);
print novo_id;

exec spProc1('Teste tres', :novo_id);
print novo_id;
    

Agora a proc já está funcionando da forma que desejamos! Um último refactoring para otimizar o código e ...

create or replace procedure spProc1(pDescricao in varchar2, pId out number) as
begin

    begin
        select Id into pId from TabA where Descricao = pDescricao;
        dbms_output.put_line('O Id encontrado foi ' || nvl(to_char(pID),'[nulo]'));
    exception
        when NO_DATA_FOUND then pId := null;
        when OTHERS then raise;
    end;


    if (pId is null) then

        select nvl(max(Id),0)+1 into pId from TabA;
        dbms_output.put_line('O Id gerado foi ' || pID);

        insert into TabA (Id, Descricao, DataCriacao)
        values (pId, pDescricao, sysdate);
        
    end if;

end;
/
show errors

exec spProc1('Teste quatro', :novo_id);
print novo_id;

exec spProc1('Teste quatro', :novo_id);
print novo_id;
    

Perfeito! A proc está exatamente como desejamos!

Agora podemos remover aquelas linhas de debug...

Mas seria interessante deixar essas linhas, para o caso de precisar depurar novamente...

Só que não é legal deixar essas linhas serem executadas SEMPRE, somente quando precisarmos
depurar.

Aí entra em cena o parâmetro opcional que comentei no início deste post. Como o parâmetro é OPCIONAL (todo parâmetro que tem um valor default pode ser otimido), você não precisa indicar o valor.

Assim, os programas que usam a proc não precisam ser alterados.

Eu defini o valor default como FALSE porque normalmente a proc não deve exibir informações de debug.

Nos casos (especiais) que eu quiser mostrar, informo explicitamente o valor true.

create or replace procedure spProc1(pDescricao in varchar2, pId out number, p_showDebug in boolean default false) as
begin

    begin
        select Id into pId from TabA where Descricao = pDescricao;
        if (p_showDebug) then
            dbms_output.put_line('O Id encontrado foi ' || nvl(to_char(pID),'[nulo]'));
        end if;
    exception
        when NO_DATA_FOUND then pId := null;
        when OTHERS then raise;
    end;


    if (pId is null) then

        select nvl(max(Id),0)+1 into pId from TabA;
        if (p_showDebug) then
            dbms_output.put_line('O Id gerado foi ' || pID);
        end if;

        insert into TabA (Id, Descricao, DataCriacao)
        values (pId, pDescricao, sysdate);
        
    end if;

end;
/
show errors


exec spProc1('Teste cinco', :novo_id);
print novo_id;

exec spProc1('Teste cinco', :novo_id);
print novo_id;

exec spProc1('Teste cinco', :novo_id, true);
print novo_id;

exec spProc1('Teste seis', :novo_id, true);
print novo_id;

Abraços e até a próxima!

LZ

www.imaginarti.com

Trielo de Hypervisors (Windows Guest)

2010-05-29T22:09:00.010-03:00

E aí, pessoal? Faz tempo, né?

Hoje eu resolvi escrever sobre um assunto que eu tenho comentado e vivido bastante, ultimamente: Máquinas Virtuais (ou hypervisors). E achei melhor fazer na forma de um trielo. Por que trielo?? Porque são três "competidores", se fossem dois seria um duelo. :-)

Eu testei o Microsoft Virtual PC, o VMWare Player e o Oracle VirtualBox. E como eu disse antes, foi uma comparação nada técnica. Eu não usei softwares de benchmarking, não medi tempos com ferramentas automáticas, muito menos carga de CPU, memória, etc. Tudo o que vou contar é simplesmente a minha impressão sobre os produtos. Se isso te ajuda, read on. Senão, sorry mate.

Eu instalei os três produtos no meu desktop. É um Athlon 64 3800+, 2Gb de RAM, HD interno 160Gb SATA, HD 500Gb SATA em um case USB, placa de vídeo NVidia GeForce 6200 com dois monitores (LG W1942S na VGA e Samsung P2470HN na DVI). As três VM foram instaladas no HD externo e os softwares para instalação também estavam neste HD externo.

A máquina física roda WinXP sp3 e tem só 2Gb. Para rodar três VMs com 512Mb cada uma, não sobrou quase nada o host OS, tadinho. A terceira VM a rodar (o VirtualPC) só subiu depois de parar vários serviços no host (entre eles SQL Server, terminal remoto, etc.). Depois de conseguir subir as 3 VM's, o host OS ficou insuportavelmente lento. Aliás, escrever este post não está sendo nada fácil...

Apesar de não ter nenhum critério técnico nesta comparação, procurei ser imparcial ao máximo. A tarefa consistia em instalar o sistema operacional (Windows XP Professional English sp2), instalar o Service Pack 3, instalar o Guest OS Additions (específico de cada produto), instalar o AVG Free, instalar o Zone Alarm e desinstalar componentes desnecessários do Windows (wallpaper, ponteiros de mouse, games, etc.). As instalações foram executadas nas 3 VM's simultaneamente (descontando o tempo de mover o mouse para a outra VM e clicar no botão). Eu pretendia instalar o Visual Studio 2010 Express, mas já gastei muito tempo e o VS vai ficar para outro dia.

E depois de algumas horas executando essas tarefas, eis as minhas impressões:

Preço

Todos os três são grátis. :-)

Contato Inicial

O VirtualPC parece ser mais fácil de operar. Talvez por ser obviamente mais simples (menos opções, menos funcionalidades), talvez por ter mais a cara (look 'n feel) do Windows, é o que oferece maior conforto para um usuário iniciante.

O VirtualPC também tem o esquema mais simples de Shared Folder (uma pasta no host que é compartilhada no guest como um drive mapeado ou um network share, para facilitar troca de arquivos entre o host e o guest).

Performance

O VirtualBox é disparado o mais performático. Iniciei algumas tarefas primeiro no VirtualPC, outras iniciei primeiro no VirtualBox e outras iniciei primeiro no VMWare Player. Em absolutamente todos os casos o VirtualBox terminou primeiro. É razoavelmente mais rápido que o VirtualPC e muito mais rápido que o VMWare Player. A diferença é absurda (usei sempre as configurações default). Na hora de instalar o SP3 do Windows foi o ápice: iniciei a instalação no VMWare Player. 5 minutos depois, comecei no VirtualPC. Passados mais 5 minutos, iniciei no VirtualBox. Quase uma hora depois, o VirtualBox terminou antes dos demais e ficou parado esperando os outros. Em seguida veio o VirtualPC e muito tempo depois o VMWare Player cruzou a linha de chegada, se rastejando. Aliás, depois de um tempo com o Windows paradinho, sem fazer nada, o VMWare Player continua acessando HD, CD e rede sem parar, enquanto os outros só acessam (muito) de vez em quando.

Usabilidade

Neste ponto eu considero um empate técnico com ligeira vitória para o VirtualBox. Todos os três produtos são bem similares, as diferenças são bem sutis. O VirtualPC tem o esquema mais simples para usar um arquivo .ISO como um drive de CD. Ponto para ele porque é realmente simples e rápido. Os outros são bem mais flexíveis, permitem ter uma biblioteca de .ISO's pré-configurada, o que permite alternar rapidamente entre as imagens ISO. Mesmo assim prefiro a facilidade do VirtualPC.

Outro ponto que achei interessante (e dessa vez ponto para o VirtualBox) é a integração com o ponteiro do mouse. Achei fantástico. Enquanto no VirtualPC e no VMWare você tem que clicar uma vez para ativar a janela (se ela não estiver ativa) e outra vez para acionar o controle (clicar em um botão, um checkbox, etc.). Já no VirtualBox o mesmo clique aciona a janela (se for necessário) e aciona o controle, tudo de uma vez só. Isso deixa a experiência do usuário particularmente confortável quando há necessidade de muitas interações dentro e fora da VM, como quando eu estava desinstalando componentes desnecessários do Windows. Nessa hora eu precisei marcar e desmarcar vários checkboxes simultaneamente nas 3 VM's.

Flexibilidade
Nesta questão, o VMWare é melhor do que o VirtualBox... e dá couro no VirtualPC. No VirtualPC há uma tecla fixa para liberar o ponteiro do mouse (quendo foi capturado pelo guest OS e a integração de ponteiro não está instalada). No VirtualBox e no VMWare esta tecla pode ser configurada (e é bem fácil de fazer).

As bibliotecas de imagens .ISO's que existem no VirtualBox e no VMWare são um conceito interessante. Facilitam na troca de mídia no CD "virtual", o que é ótimo se você precisa instalar várias VM's com a mesma mídia... Ou se precisa ficar alternando mídias (bota um disco, bota outro disco, bota um disco, bota outro disco, ...). O mesmo não dá para fazer com o VirtualPC. E se as mídias .ISO estiverem em pastas diferentes, a tarefa fica bem tediosa.

O VirtualBox e o VMWare reconheceram de cara os dispositivos USB ligados no host (o HD externo e o leitor de cartões, que apesar de interno, é USB). Reconheceram até a marca (JMicro) e modelo (JM20336) do case que contém o HD (o HD externo é esse case + HD de notebook). Ambos os softwares ofereceram menus para ligar os dispositivos USB (e acessá-los diretamente). Além dessa opção no menu, também há essa opção através de ícones na barra de ferramentas na parte inferior da janela da VM (um atalho). O VMWare chegou a me oferecer isso através de uma janela (com botões "sim" e "não"). O VirtualPC passou longe de saber que há algum USB espetado, embora afirme que é possível conectar as COM e a LPT do host. Eu não usei essas opções, mas achei interessante a possibilidade.

Outros aspectos
O reconhecimento da placa de som é bem transparente nos três produtos e mapeamento da placa virtual para a física ocorreu sem problemas.

O hardware virtual disponibilizado pelo VMWare reportou suportar PAE (Physical Address Extension). Os outros produtos não reportaram PAE.

Quando se cria uma VM com o VMWare, ele te pergunta se você quer criar o HD virtual como um arquivo único ou se quer dividir em arquivos de (no máximo 2Gb). É ótimo ter a opção de escolher (principalmente se você precisar copiar o HD virtual entre computadores diferentes), mas a maneira do VirtualPC (arquivo único) é bem mais simples. O VMWare tem um monte de arquivos, dá a impressão de ser meio confuso. O VirtualBox criar os HDs virtuais como arquivos únicos e permite compartilhar um mesmo HD Virtual entre várias VM's. Flexibilidade total e um recurso interessante, mas é um conteito muito estranho para quem nunca tinha ouvido falar, que era o meu caso. Levei um tempinho até entender como a coisa funciona.

O VMWare tem um recurso muito interessante para auxiliar na instalação de um sistema operacional. Ele é tão esperto que pode interagir com o programa de instalação e fornecer informações (previamente fornecidas por você ou baseadas no default do programa) de forma que a instalação pode acontecer de forma não assistida. Por isso, instalar o Windows XP no VMWare é muito mais rápido que qualquer outro: enquanto os concorrentes ficam esperando você informar a CD-KEY ou clicar em "configurações padrão" (na instalação da rede), o VMWare se vira sozinho e não fica esperando por você. Resultado: menor tempo de instalação, menos tempo que você "perde".

Há um recurso no VirtualBox e no VMWare (novamente o VirtualPC ficou de fora) que deixa o uso bem interessante: é a possibilidade de executar uma determinada aplicação sem exibir o desktop virtual (a janela da aplicação rodando no guest é exibida diretamente no host). Assim, dá a impressão que a aplicação está rodando no host (já que só a aplicação é visível e deixa de estar restrita ao tamanho do desktop do guest), mas na verdade ainda é uma máquina virtual. Esse recurso é chamado de unity no VMWare e modo seamless no VirtualBox. Vale a pena experimentar.

Com relação ao consumo de memória do host, o VirtualBox passa a impressão de ir obtendo memória à medida que o guest for precisando. O VirtualPC e o VMWare, ao contrário, reservam a quantidade de RAM que a VM precisa, logo que a VM é iniciada. Sem ferramentas fica difícil comprovar essa teoria (também não achei nada a esse respeito na documentação), mas é fácil acompanhar a quantidade de memória em uso pelo processo, usando o Gerenciador de Tarefas do Windows host. A medida que a VM vai iniciando processos, esta VM vai aumentando o consumo de memória no host. Já no VirtualPC e no VMWare, o consumo de memória é fixo. Isso é um aspecto muito interessante porque, dependendo do que a VM for executar e da quantidade de memória disponível no host, o uso do VirtualBox pode não deixar o host tão lento.

Rodar três VM's no mesmo HD externo... Dá para fritar um ovo no chassi do HD externo.

Conclusão

Diante de todos os aspectos que eu experimentei, eu penso que o VirtualPC é muito básico. Serve apenas se você tem muito pouca necessidade de rodar uma máquina virtual e se ela for Windows. Por exemplo: se você precisa executar uma versão anterior do IE, ou uma tarefa básica assim, VirtualPC 2007 te cai bem.

O VMWare Player é um produto bastante robusto e acho que ele serve bem se você precisa usar uma VM para fins profissionais (mesmo com o apetite por I/O). Com esta versão free, você pode ter várias VM's, mas só pode rodar uma de cada vez. Tem excelente suporte a hardware e se você tem uma CPU com suporte a virtualização assistida por hardware.

O Oracle VirtualBox é outra excelente opção, principalmente se você rodar mais de uma VM por vez. É o produto que eu mais gostei pela perfeita integração com o ponteiro do mouse, pelo consumo moderado de memória do host, pela possibilidade de rodar mais de uma VM. O que ele eventualmente perde para o VMWare Player não chega a fazer falta. É por isso que vou ficar com este produto.

Vejam uma foto do meu desktop com as três VM's rodando ao mesmo tempo.

Vale ressaltar que eu não testei Microsoft Virtual Server, nem o Virtual PC para Windows Seven (e o famoso XP Mode), nem o Oracle VM Server, nem o VMWare Workstation (nem irmãos "maiores"). Também não testei XEN e outros produtos famosos do mercado. Testei apenas os que eu tinha à mão e que são alguns dos mais comuns.

Espero que minhas impressões possam ajudar alguém por aí.

Forte abraço e até a próxima.

SQL Server - E porque eu gosto mais do Oracle (temporary table)

2009-09-17T02:56:00.004-03:00

De volta ao duelo SQL Server x Oracle.

Como hoje eu estava comentando com um amigo no trabalho sobre as tabelas temporárias, resolvi aproveitar e escrever sobre o assunto.

Rápido esclarecimento (se há alguém que ainda não sabe!): uma tabela temporária é aquela que cujos dados estão "visíveis" somente à sua sessão e, depois de usados são descartados (não são gravados em disco).

Pela ANSI há dois tipos de tabelas temporárias: as locais e as globais.

As LOCAIS são criadas no momento em que são necessárias (ou seja, "on the fly"), não estão presentes no catálogo do banco, são usadas e, quando não são mais necessárias são destruídas.

As GLOBAIS são criadas previamente ao uso, fazem parte do catálogo e, quando não são mais necessárias, apenas os dados são descartados.

Em linhas gerais, o SQL Server trabalha somente com temporárias locais, enquanto o Oracle trabalha somente com temporárias globais.

E porque eu prefiro as globais?

1) Porque fazem parte do catálogo. Assim eu posso escrever várias stored procedures que usam a mesma temp table, sem preocupações. Inclusive os planos de acesso são previamente compilados. Posso estabelecer foreign keys. Ou seja, garantem a integridade dos dados com menos trabalho.

2) DDL é "caro". Os comandos do tipo DDL (data definition language) consomem muito tempo de CPU (tempo de "preparação", ou seja, interpretação, compilação, etc., não tempo de execução) se comparados com os DML (data modification language). E quando o programa / sistema / software está rodando, você quer que rode o mais rápido possível. Não "perder tempo" criando e destruindo objetos é um recurso valioso.

3) No Oracle eu posso definir em que momento os dados serão desprezados, se no commit ou se no disconnect. Isso é feito de forma declarativa, na criação da tabela, e me dá mais flexibilidade do que o SQL Server, que só oferece uma forma automática de desprezar os dados (no disconnect, quando a tabela é destruída).

O primeiro argumento é definitivamente o mais forte, pois trás à reboque outros argumentos (por existir no catálogo eu posso isso, eu posso aquilo, etc.).

Concordam? Discordam? Dêem suas opiniões!

Até a próxima!

A luta contra o SPAM

2009-07-26T18:55:00.013-03:00

Como a empresa é bem pequena (somos equipe, digamos... reduzida!), eu acumulo tarefas. Uma delas é ser o administrador do correio eletrônico. E hoje vou comentar sobre o saco que é lutar contra o SPAM.

Como toda microempresa que se preza, eu não posso me dar ao luxo de perder um email enviado a nós... pois ali pode ter uma oportunidade interessante. Penso que algumas empresas maiores se permitam monitorar somente as caixas postais formalmente publicadas no seu site... Como não é o caso, eu configurei uma conta para ser Catch-All.

Como essa Cacth-All (eu detesto o termo em Português: "Pega-Tudo". Argh!) recebe mensagens que foram enviadas a caixas postais que não existem, é ali que se acumula o spam. E que saco é lutar contra o maldito spam.

Como o volume de spam é bem alto, você logo começa a catar ferramentas para eliminar essa praga. Usamos o SmarterMail Enterprise, que tem umas ferramentas anti-spam que até ajudam, mas não fazem tudo. Então eu comecei a analizar o maldito spam que chegava.

Obervando o cabeçalho das mensagens percebi que a maioria (eu chutaria uns 70%) chega no meu servidor diretamente de uma máquina que parece ter IP dinâmico... um usuário de banda larga. Obviamente infectado com algum vírus, que se aproveita da banda do incauto. Como esse exemplo:

Received: from client-82-12-232-213.brnt.adsl.virgin.net [82.12.232.213] by meu.servidor.de.email with SMTP;

Isso é uma das linhas de cabeçalho de uma das mensagens indesejadas. Ela diz que a mensagem foi recebida pelo meu servidor de mail (mudei o nome de propósito), através de uma conexão SMTP (o protocolo de envio de emails) que foi iniciada pelo computador client....virgin.net. Nem me dei ao trabalho de checar, mas sou capaz de apostar como Virgin.Net é o domínio de algum provedor de banda larga. Repare no no IP (entre colchetes), que é repetido no nome do computador (que é dado pelo DHCP). Repare também no ".adsl.". Bingo. Usuário de banda larga infectado.

Ok, mas o que eu faço com isso??
Uso uma outra ferramenta do meu servidor de email, que é o filtro de conteúdo. Criei uma regra que apaga automaticamente todas as mensagens que tenham no cabeçalho, a linha acima, só que com uma pequena modificação: usando wildcards (que o servidor "entende"). Fica assim:

Received: from client-*.brnt.adsl.virgin.net [*] by meu.servidor.de.email with SMTP;

Ou seja, agora minha regra é: apagar todas as mensagens que sejam recebidas pelo meu servidor, enviadas diretamente de qualquer usuário de banda larga dessa tal de virgin.net.

Uma ou duas vezes por semana, preciso acrescentar entradas novas nesta regra, mas o volume de spam cai muito. Mostrou-se ser uma boa prática.

Espero que a dica ajuda mais alguém por aí.

Abraços e até a próxima!

Aggregation X Delegation - round 2

2009-06-07T17:40:00.008-03:00

De volta ao assunto do como montar objetos "compostos".

Como regra geral eu gosto bem mais da solução de Delegação. Acho mais elegante, mais conforme os princípios de OO, e de mais fácil compreensão também. Mas como eu já disse, isso é apenas minha opinião. E a sua, leitor, qual é?

É fato também, que a solução de Agregação tem lá o seu lugar ao sol. Por exemplo: como definir o DisplayMember e o ValueMember de um WinForm.ComboBox com objetos compostos? Algo como ...

cboMeuComboBox.ValueMember = oMeuObjeto.SubObjeto.Id;
cboMeuComboBox.DisplayMember = oMeuObjeto.SubObjeto.Descricao;

... simplesmente não funciona. Nesse caso, eu acabo adotando a agregação, e fica mais ou menos assim:

cboMeuComboBox.ValueMember = oMeuObjeto.SubObjeto_Id;
cboMeuComboBox.DisplayMember = oMeuObjeto.SubObjeto_Descricao;

Isso mesmo, agrego as propriedades de SubObjeto diretamente como propriedades em MeuObjeto. É estranho e poluído, mas funciona 100%.

Atualmente eu tenho preferido sempre a solução de Delegação. Mas nesses casos mais particulares, não tem jeito... uso mesmo a Agregação. E claro, isso só comprova a nossa velha teoria, que "não existe bala de prata".

Até a próxima,

Bug Publicando ClickOnce via FTP

2009-05-22T20:49:00.008-03:00

No VS2005, há um bug bem conhecido pelo pessoal que usa ClickOnce e publica via FTP: Ao final do processo, o VS simplesmente dá um erro e aborta. É bem chato, principalmente se você estiver fazendo testes de publicação... Toda hora tem que iniciar o VS de novo, abrir a sua solução de novo...

Eu rodei a internet e nunca encontrei uma solução para isso. Até agora! É, porque hoje, por acaso, eu acabei descobrindo uma forma de impedir o bug de ocorrer...

Basta desmarcar a opção para exibir a página de deploy após a publicação (Propriedades do Projeto, aba Publish, botão Options, como figura abaixo). Feito isso, a publicação funciona numa boa... sem crash no final! Funciona tanto publicações FTP como file share (que tem o mesmo bug).

Eu ainda não testei no VS2008. Aliás nem sei se nessa versão corrigiram este bug.

De qualquer forma, tomara que essa dica ainda ajude alguém.

Até a próxima!

SQL Server - E porque eu gosto mais do Oracle (owner name)

2009-05-09T20:25:00.008-03:00

Quem me conhece pessoalmente, sabe que eu prefiro o Oracle sobre o SQL Server. Não, eu não sou nenhum pregador anti-Microsft, nem defensor ferrenho de tecnologias OpenSource... nenhum desses blá-blá-blás "anti-semitas". Eu tenho lás as minhas preferências, mas geralmente são baseadas em bons motivos técnicos.

E hoje eu vou contar um dos motivos pelos quais eu gosto mais do Oracle do que do SQL Server. Para facilitar a compreensão, as espressões usuário, esquema e owner são usadas com o mesmo significado.

Em ambos os SGBDs você pode criar objetos (tabelas, views, procs, etc.) privadas (que são de um "usuário" em particular) ou públicas (de nenhum usuário em particular).

Claro que há algumas diferenças de como os dois bancos interpretam essa questão, mas a regra geral é se você não especifica o owner do objeto, está falando de um objeto que está no seu esquema (ou que pertence ao usuário corrente). E daí tem os efeitos colaterais (positivos e negativos):

Se você está criando um objeto, e não especifica o owner, ele será criado no seu usuário.
Se você está se referindo à um objeto, e não especifica o owner, está falando do objeto que existe no seu usuário. Se não existir no seu usuário, então vc está falando do público. Se não existir, é erro mesmo.

Até aí tudo bem, inclusive porque, como vocês sabem, e também por dedução lógica dos princípios acima, você pode "falar de um objeto" sem mencionar o owner, e o banco se encarrega de achar aquele que vai te servir.

O detalhe sórdido é que o SQL Server tem uma exceção: Para functions, isso só funciona assim se o objeto é do dbo (público) e o usuário tem a role db_owner. Se não for assim, você é OBRIGADO a informar o owner da function.

Ok, Léo, mas o que isso pega?
Bem, respondo, se você trabalha em um ambiente não muito restrito, não vai pegar nada. Você vai usar o nome do owner e tudo bem. Já se você tem restrições, o bicho pega. Em locais que impõem regras rígidas de segurança (como empresas grandes, ou provedores de hospedagem), raramente você se conecta no SGBD com o mesmo usuário que é dono dos objetos.

Ficou confuso né? ok, não sou um escritor experiente. Vamos a um exemplo prático:
Eu estava criando um banco SQL Server que ia ser hospedado em um servidor de hospedagem. O cliente final é dono da conta e tem vários sistemas. Então ele tem um login dele (vamos dizer: "cliente"), e criou outro especificamente para este sistema (digamos "sistema1").

Quando criei os objetos, não especifiquei owner, então ficou tudo assim: sistema1.tabelaA, sistema1.tabelaB, sistema1.viewC, sistema1.ProcD.

Aí eu precisei criar uma função. E no código fonte, fui obrigado a dizer o owner da função. Só que o nomedo owner muda de acordo com o ambiente onde está sendo executado. Se é aqui dentro da empresa (onde é desenvolvido), o owner é um. Se é lá na hospedagem, o owner é outro. Então, restaram duas alternativas:

Ou eu uso o owner exatamente igual tanto na hospedagem (ambiente de produção), quanto no desenvolvimento (o que nem sempre é possível, pq sempre temos que seguir regras de nomenclatura, que variam de empresa para empresa);

Ou eu ignoro a possibilidade de usar mais de um usuário... e tudo passa a ser dbo. Como nesse caso, isso me traria menos problemas, essa foi a solução que adotei. Então mudei o owner de todos os objetos do banco para dbo (para quem não sabe, existe a sp_changeobjectowner que faz isso, e eu montei um script fazendo um select diretamente no catálogo).
E também tive que mudar os scripts de criação e alteração de TODOS os objetos para incluirem o prefixo "dbo.".
E o código que acessa a function ficou "dbo.MinhaFuncao".

Foi um saco, mas funcionou. Aí vai a manha:

select 'exec sp_ChangeObjectOwner ''' + name + ''', ''dbo''' as cmd from sysobjects where xtype in ('U','FN','P')

Tomara que ajude alguém.

Até a próxima.
LZ

Aggregation X Containment/Delegation

2009-05-02T12:45:00.008-03:00

Eu sempre tenho essa dúvida na hora de construir meus objetos. Às vezes prefiro delegação. Outras Agregação. A quem é novo em POO, aqui vai um breve esclarecimento:

Problema:
Você tem uma entidade chamda "Cliente". Seus atributos são Nome, CPF e DataNascimento. Você também precisa de um atributo EstadoOrigem (unidade da federação onde o cliente se cadastrou). Você ia criar um atributo EstadoOrigem, do tipo string (onde você imagina armazenar a sigla, com dois caracteres), mas acabou de enxergar que Estado é um entidade tão importante no sistema, a ponto de ser representada realmente como uma entidade. :-)

Você faz uma pausa em Cliente e modela a entidade Estado: NomeEstado e Sigla (vamos deixar todos os IDs fora de questão por enquanto, ok?).

Com a entidade Estado na mão (que vai virar uma classe durante a programação), você olha de volta para cliente e pensa: Como vou representar o estado de origem do cliente?

Solução 1: Agregação
Uma solução, chamada de Agregação, é agregar os atributos da "sub-entidade" na "entidade-raiz". Ou seja: Cliente teria os seguintes atributos Nome, CPF, DataNascimento, NomeEstado, SiglaEstado.

Efeitos colaterais? agora precisamos representar a UF de nascimento do cliente. Teríamos 2 NomeEstado e 2 SiglaEstado. Poderíamos nomear o segundo par de atributos como NomeEstadoNascimento e SiglaEstadoNascimento. O nome seria bastante claro, mas o primeiro par não está tão claro assim. Então seria melhor renomear o primeiro para NomeEstadoOrigemCadastro e SiglaEstadoOrigemCadastro.

Alguns puristas diriam que esta abordagem fere um dos princípios básicos de origentação à objetos (encapsulamento). É verdade, eu também acho que fere, mas é um "mal necessário", às vezes.

Solução 2: Delegação (ou Contenção ou Composição)
Outra solução é compor a entidade Cliente com outra(s) entidades, na forma de atributos. Então Cliente teria os seguintes atributos: Nome, CPF, DataNascimento e EstadoOrigem, sendo que EstadoOrigem tem os atributos NomeEstado e SiglaEstado.

Nas linguagens de programação (a maioria) ficaria algo assim:

txtValor.Text = objCliente.EstadoOrigem.NomeEstado

Eu gosto mais dessa abordagem. Escreve-se menos, é mais clara (eu acho esse código mais limpo). Mas a prática mostra que isso tem lá os seus drawbacks.

Conclusão
Como eu já conheço alguns pontos positivos e negativos das duas formas, eu vou usando aquela que eu acho que vai se encaixar melhor em cada caso. Ou seja, eu não tenho uma solução única para todos os casos. "Não existe bala de prata", mas sim, a ferramenta certa para o trabalho certo.

Eu vou voltar a este assunto mais tarde, mas antes queria saber das opiniões dos leitores... que abordagens preferem e seus motivos.

Até a próxima.

LZ