Lazarus - Dicionários de Dados

Dicionários de dados são repositórios com metadados sobre bancos de dados, que descrevem a estrutura básica de um esquema de banco de dados. Num dicionário de dados as seguintes informações são armazenadas: as tabelas e os campos correspondentes, e os índices existentes nas tabelas. Além disso, os dicionários de dados contém atributos que definem como o conteúdo dos campos devem ser visualizados: número de casas decimais, o rótulo, a dica (hint) mostrada, tamanho do campo, entre outros.
Um dicionário de dados pode ser usado por uma aplicação Lazarus para definir as propriedades dos objetos TField; pode ser usado para criar comandos SQL, por exemplo, para criar o banco de dados descrito; e, a partir da comparação entre dois dicionários, as diferenças entre eles podem ser usadas para criar um script de atualização.
Os dicionários de dados podem ser mantidos usando o Lazarus Data Desktop, que começamos a descrever no post Lazarus - o Lazarus Data Desktop. Usando esta ferramenta podemos criar um dicionário novinho em folha ou importá-lo a partir de um banco de dados existente.

Criando um Dicionário de Dados

Para criar um novo dicionário clique no botão correspondente na barra de ferramentas conforme mostra a figura, ou tecle CTRL + N.

Isso irá criar uma nova aba. Clique com o botão direito no interior da aba e em seguida na opção New Table, ou tecle CTRL + T, para criar uma nova tabela. Digite o nome da tabela na caixa de diálogo e confirme.
Agora clique com o botão direito sobre o nome da tabela recém-criada e escolha a opção New Field. Digite o nome do campo e confirme. Um novo campo será criado e um formulário para definir as propriedades do campo será aberto no lado direito da interface, como podemos ver na figura abaixo.

Algumas propriedades que podem ser definidas, entre outras:
DisplayName - rótulo do campo que poderá ser visualizado em uma TDBGrid, por exemplo;
DisplayWidth - tamanho com que o campo será exibido;
FieldType - tipo de dado do campo;

Após criar todas as tabelas e campos, tecle CTRL + S para salvar.

Gerando comandos SQL a partir do Dicionário

Para gerar os comandos SQL pressione o botão correspondente conforme mostra a figura abaixo ou tecle CTRL + G.

Essa ação irá abrir um novo formulário. Escolha a tabela para a qual deseja gerar os comandos SQL. Na lista Key fields selecione o(s) campo(s) que será chave primária. Na lista Select/Update/Insert fields selecione o(s) campo(s) que serão usados nos comandos SELECT, UPDATE e INSERT. Pressione o botão Generate SQL. Clique em cada uma das abas para ver os comandos gerados. Na figura seguinte mostramos o comando CREATE TABLE que foi gerado.

Importando o Dicionário de Dados

Se já tivermos um banco de dados criado, podemos criar o dicionário a partir dele - processo que é chamado engenharia reversa.
Inicialmente crie uma conexão para o banco de dados existente conforme mostramos em Lazarus - o Lazarus Data Desktop. Em seguida selecione no menu Dictionary > Import > From connection. As conexões criadas na ferramenta estarão disponíveis nessa opção. Escolha aquela para a qual você precisa criar o dicionário.
Uma caixa de diálogo será aberta mostrando as tabelas do esquema. Selecione as tabelas desejadas, deixe marcada a caixa Update existing tables para atualizar tabelas que já existem e confirme.

Se houver um dicionário ativo na ferramenta, você será questionado se deseja atualizar ou criar um novo. Clique CTRL + S para salvar o dicionário. Os dicionários de dados são salvos com a extensão .fpd. Você pode visualizar o arquivo de dicionário de dados usando qualquer programa que abre arquivos texto.
Fica para o próximo post a utilização de dicionários de dados em aplicações Lazarus.
Post escrito tendo como referência o livro Lazarus - the Complete Guide, publicado pela Blaise Pascal Magazine.

Lazarus - O Lazarus Data Desktop

Se em suas aplicações você utiliza diversos bancos de dados, é provável que também precise de uma ferramenta específica para cada SGBD, com a finalidade de criar tabelas, criar comandos DML e DDL, entre outros. A fim de centralizar todas as tarefas do desenvolvedor no Ambiente de Desenvolvimento, o Lazarus oferece o Lazarus Data Desktop. Também chamado Database Desktop, esta ferramenta dispõe de vários recursos, dentre os quais destacamos:

• Acesso a todos os bancos de dados suportados pelo Lazarus;
• Criação de um dicionário de dados onde as propriedades de TFields podem ser armazenadas;
• Criação de comandos DDL e DML a partir do dicionário de dados;
• Consulta à tabelas;
• Exportação de dados de tabelas para diversos formatos: XML, JSON, CSV, entre outros.

Para usar esta ferramenta. primeiramente é necessário compilá-la. Ela está localizada em tools/lazdatadesktop, no diretório home do Lazarus. Abra então o projeto lazdatadesktop e compile-o.
Para integrar a ferramenta ao IDE, abra e instale o pacote lazDataDict, localizado no diretório components/datadict. Após isso o IDE será estendido em três novas opções:

1. Um novo item de menu será registrado no menu Project - com o nome Data Dictionary. Esta opção irá permitir que escolhamos um dicionário de dados para o projeto;
2. No menu Tools será acrescentado o item de menu Database Desktop, que executa o Lazarus Data Desktop;
3. Finalmente no Form Designer, um novo item é registrado no menu local que pode ser usado para aplicar o dicionário de dados a um TDataset - o item de menu Data Dictionary.

Vejamos então como utilizar o Lazarus Data Desktop.

Conectando-se a bancos de dados

Para fazer uma conexão use a opção de menu Connections > New connection, como mostra a figura abaixo:

Esta ação abrirá uma caixa de diálogo onde você irá escolher o banco de dados:

Selecione o banco de dados e você será levado a um novo diálogo para informar os dados da conexão:

Após informar os dados e confirmar será solicitado um nome para a conexão. Confirme também, após informar o nome e será adicionada uma nova aba ao ambiente com as informações da conexão. No lado direito da tela existe a aba Run Query,  que possibilita executar uma consulta e exportar o resultado da consulta, entre outros recursos.

Exportando dados de uma tabela

Para exportar os dados resultantes de uma consulta, use o botão Export this data que será habilitado após a execução bem sucedida de uma Query. Em seguida escolha o tipo de arquivo, por exemplo CSV, e confirme. Então será mostrado um diálogo onde se pode escolher os campos da tabela a serem exportados, o caminho e o nome do arquivo destino e opções de formatação, conforme pode ser visto na figura a seguir.

Depois de confirmar o arquivo exportado será criado.

Gerando código Free Pascal

Outro recurso importante do Lazarus Data Desktop é a criação de código em Free Pascal. Pode-se gerar código quando estamos visualizando o resultado de uma Query ou quando estamos examinando a definição de uma tabla no dicionário de dados.
Os códigos que podem ser gerados são:

• Uma constante string a partir do comando SQL quando se está visualizando o resultado de uma consulta;
• O código para criar uma tabela DBF a partir dos dados que estão sendo mostrados;
• Uma classe Object Pascal e suas propriedades baseados em um Dataset e seus campos;
• Uma declaração de classe tiOPF para usar com Object Persistence Framework.

Por exemplo, na aba Run Query, após executar uma consulta, clique no botão Create pascal code for this data. Escolha em seguida a opção Simple object/collection for the data. Será aberto o seguinte diálogo:

Nessa tela você define o caminho e nome do arquivo onde deseja salvar o código e os campos da tabela que serão propriedades da classe. Para cada campo da tabela é possível definir propriedades, bem como definir algumas propriedades da própria classe na aba Options. Confirme e uma tela com o código gerado será aberta, conforme mostra a figura seguinte:

Apesar de ter um botão Save, isso não será mais necessário, pois o código já está salvo no arquivo informado na tela anterior.
No próximo post veremos os procedimentos para criar dicionários de dados no Lazarus Data Desktop e como utilizá-los em nossas aplicações de banco de dados.
Post escrito tendo como referência o livro Lazarus - the Complete Guide, publicado pela Blaise Pascal Magazine.

Lazarus - Livro sobre Lazarus em Português

"Desenvolvendo Aplicativos com Lazarus" (agbook, 2011, 344 páginas), produzido pelo paraense Jean Patrick, reúne um conjunto de informações valiosas sobre o IDE Lazarus, que chegam em boa hora para suprir uma necessidade urgente daqueles que, ou pretendem adotar uma nova ferramenta de desenvolvimento ou gostariam de melhorar seu conhecimento sobre o IDE.
O livro está organizado em 14 capítulos e 5 apêndices. Sendo que os nove primeiros capítulos passam por vários tópicos, alguns bem superficialmente tal como as paletas de componentes, e dá mais destaque à configuração no IDE no Capítulo 6.
Para os que preferem ação, ela começa mesmo no Capítulo 10. Nesse capítulo são desenvolvidos três projetos, o que dá uma boa noção do poder de fogo do Lazarus. Os projetos usam componentes básicos e há farta utilização de eventos e código. Desta forma o leitor terá um bom suporte para o que vem pela frente, que é o desenvolvimento usando banco de dados.
Uma introdução a banco de dados é feita no Capítulo 11. No Capítulo 12 são usados os componentes nativos do Lazarus para conexão a bancos de dados - a paleta SQLdb. Aqui é criada uma aplicação para controle de cheques usando o banco de dados sqlite.
Um cadastro de produtos usando banco de dados Firebird é criado no Capítulo 13. Neste caso o livro apresenta o conjunto de componentes ZeosLib, ZeosLib é uma biblioteca de terceiros e considerada melhor que SQLdb para aplicações de maior porte.
A criação de relatórios é abordada no Capítulo 14, onde se destaca o conjunto LazReport, nativo do Lazarus. Documentação sobre LazReport é muito raro. Esse é capítulo que vai ajudar muito aos desenvolvedores.
Nos apêndices destacamos os recursos do IDE para tratamento de arquivos texto e algumas dicas para programar aplicações multiplataforma. Inclusive é criada uma pequena aplicação para demonstrar o uso dos componentes oferecidos pelo Lazarus para acessar arquivos texto.
É uma obra que precisa do incentivo da comunidade para crescer ainda mais. Costumo dizer que só com a divulgação de conteúdo de valor é que será possível a disseminação do uso deste poderoso IDE.
Os interessados em adquirir um exemplar acessem o site da agbook.

Curso de Introdução ao Free Pascal/Lazarus - Gratuito

Desenvolver aplicações usando um IDE como o Lazarus, pressupõe conhecimento da linguagem de programação subjacente. Pois a criação de um programa sempre irá precisar que se escreva algum código, principalmente para os eventos. No caso do Lazarus estamos falando do Free Pascal. Este é um curso introdutório ao Free Pascal oferecido na modalidade à distância e está organizado em oito módulos:

1. Princípios básicos, tipos, variáveis, constantes e comando de atribuição
2. Comandos condicionais (if)
3. Comandos de repetição (while, repeat e for)
4. Tipos definidos pelo usuário (subrange, set, enumerados, arrays, registros)
5. Ponteiros
6. Procedimentos e funções
7. Manipulação de strings
8. Classes e objetos

O curso será ministrado no ambiente virtual de aprendizagem Moodle. É uma ferramenta voltada para ensino à distância com todos os recursos de um ambiente dessa natureza: chat, fórum, exercícios, questionários, etc.
Caso você tenha interesse em fazer o curso, faça sua pré-inscrição aqui. Assim que completarmos a turma enviaremos um e-mail a você informando a data de início do curso e seu login e senha de acesso ao ambiente de aprendizagem.
Pré-inscrições encerradas.

Atualizado em 03/07/2011.

Free Pascal - Usando TList

A classe TList é usada para gerenciar uma coleção de ponteiros, com a grande vantagem de ser dinâmica. Ela dispõe de métodos para fazer busca na lista e ordenar os elementos, entre outros. No exemplo abaixo fazemos uso de alguns desses métodos.

unit Unit1;

{$mode objfpc}{$H+}

interface

uses
  Classes, SysUtils, FileUtil, Forms, Controls, Graphics, Dialogs, StdCtrls;

type
  TContato = class
    private
      NomeContato     : String;
      TelefoneContato : String;

    public
      property Nome : String
          read NomeContato;
      property Telefone : String
          read TelefoneContato;

      constructor Create(const pNomeContato       : String;
                         const pTelefoneContato   : String);
  end;

  { TfrmTlist }

  TfrmTlist = class(TForm)
    Button1: TButton;
    ListBox1: TListBox;
    procedure Button1Click(Sender: TObject);
  private
    { private declarations }
    Agenda : TList;

    procedure MostraAgenda;
  public
    { public declarations }
  end;

var
  frmTlist: TfrmTlist;

implementation

{$R *.lfm}

constructor TContato.Create(const pNomeContato      : String;
                             const pTelefoneContato : String);
begin
  self.NomeContato     := pNomeContato;
  self.TelefoneContato := pTelefoneContato;
end;

function comparaPorNome(Item1 : Pointer; Item2 : Pointer) : Integer;
var
  contato1, contato2 : TContato;
begin
  contato1 := TContato(Item1);
  contato2 := TContato(Item2);

  if      contato1.Nome > contato2.Nome
  then Result := 1
  else if contato1.Nome = contato2.Nome
  then Result := 0
  else Result := -1;
end;

procedure TfrmTlist.Button1Click(Sender: TObject);
var
  contato : TContato;

begin
  Agenda := TList.Create;

  contato := TContato.Create('Nádia Alves', '3523-0001');
  Agenda.Add(contato);
  contato := TContato.Create('Célio Silva', '3524-0000');
  Agenda.Add(contato);

  Agenda.Add(TContato.Create('Hélio Costa', '3320-1000'));
  Agenda.Add(TContato.Create('Aldo Sousa', '3321-0001'));

  MostraAgenda;
  ShowMessage('Ordenando pelo nome. Pressione OK');
  Agenda.Sort(@comparaPorNome);

  MostraAgenda;
  ShowMessage('Inserindo novo contato. Pressione OK');
  Agenda.Insert(2, TContato.Create('Luis Gonzaga', '3325-4000'));
  MostraAgenda;
  ShowMessage('Excluindo um contato. Pressione OK');
  Agenda.Delete(4);
  ShowMessage('Pressione OK');
  Agenda.free;
end;

procedure TfrmTlist.MostraAgenda;
var
  i : Integer;
begin
  ListBox1.Items.Clear;
  for i := 0 to Agenda.Count-1 do
  begin
    ListBox1.Items.Add(TContato(Agenda[i]).Nome+' - '+
                      (TContato(Agenda[i]).Telefone));
  end;
end;

end.

No exemplo criamos uma classe Contato que será usada para povoar um TList que denominamos Agenda. Um TListBox é usado para apresentar os dados do TList.
Nas linhas que vão de 74 a 95 é onde acontece tudo que pretendemos mostrar. Inicialmente o TList é criado. Em seguida, são criados vários objetos Contato, que são adicionados à Agenda utilizando o método Add(). Este método sempre adiciona um objeto no fim da lista.
Após isso chamamos o método MostraAgenda, que foi criado para visualizar os dados da Agenda no TListBox. Na linha 86 há uma chamada ao método Sort(), que recebe como argumento o método comparaPorNome(). Aqui cabe uma explicação mais detalhada.
A ordenação de uma lista de objetos não é uma coisa tão natural como ordenar números inteiros ou strings. Como sabemos um objeto tem vários campos e por isso precisamos definir qual o critério que será usado para decidir que um objeto A é maior, menor ou igual a um outro objeto B. Por este motivo o método Sort() deve receber como parâmetro uma variável procedural, ou seja, um método que estabelece o critério de ordenação.
Dessa forma, foi criado o método comparaPorNome(), que recebe os ponteiros dos dois objetos a serem comparados. Tal método deve retornar -1 se o primeiro objeto for menor que o segundo, 1 se for maior e 0 se forem iguais. No nosso exemplo definimos que dois Contatos são iguais quando tem nomes iguais. Leia mais sobre variáveis procedurais no post Free Pascal - Variáveis Procedurais. Deve-se ressaltar que o Free Pascal define apenas como deve ser a assinatura do método que ele espera receber em Sort(). A implementação cabe ao desenvolvedor.
Na linha 90 um novo objeto é inserido na posição 2 do TList. Note que a primeira posição é 0.
Usamos o método Delete() para deletar um objeto em uma determinada posição. Na linha 93 excluímos o objeto da posição 4.
Quando a TList não é mais necessária, liberamos a memória usada chamando Free. Para criar uma lista de strings prefira usar TStrings ou sua descendente TStringList.

Lazarus - Acessando banco de dados com SQLdb - Parte III

Muita coisa mudou no Lazarus desde que começamos a dedicar este blog à divulgação deste poderoso IDE. Quando iniciamos usávamos a versão 0.9.28 e publicamos dois artigos voltados para o uso do conjunto de componentes SQLdb:

Lazarus - Acessando banco de dados com SQLdb - Parte I
Lazarus - Acessando banco de dados com SQLdb - Parte II

Hoje estamos com a versão 0.9.31. Neste post iremos apresentar algumas mudanças para melhor na utilização desses componentes.

Referências aos campos de uma tabela - criação de TFields

Para criar os TFields ainda é necessário que a TSQLQuery esteja ativa. Dê um duplo clique na TSQLQuery e você verá uma janela como esta:

Esta janela oferece uma barra de ferramentas bastante intuitiva. O botão adicionar irá abrir uma nova janela onde você poderá selecionar os campos da tabela que se deseja adicionar. Após selecionar os campos pressione o botão Create. O botão novo campo permite criar um campo de dado, calculado ou lookup. O uso desse botão irá abrir a seguinte janela:

Aqui você escolhe o tipo do campo em Field Type. Em Field properties podemos definir os valores das propriedades do campo. Depois confirme tudo pressionando Ok. Esteja sempre atento que as tabelas envolvidas na criação dos campos devem estar abertas.
Note também que esse procedimento irá criar variáveis do tipo TField, que podem ser usadas no código do nosso programa. Essas variáveis são criadas abaixo do Data Module conforme podemos ver na figura:

A partir disso, podemos acessar os campos da tabela usando essas variáveis, lembrando que elas são objetos. Veja alguns exemplos de utilização desses objetos:

queCidadeidcidade.Value;  // lê o valor do campo, inteiro nesse caso

queCidadeidcidade.AsString;  // lê o valor do campo convertido para string

Criação de TFields não é uma novidade. Isso já existia nas versões anteriores. Apenas ficou um pouco mais intuitivo e fácil manipular a criação desses objetos.

Referência aos parâmetros de um comando SQL

Como sabemos, é possível escrever comandos SQL utilizando parâmetros. Um exemplo é mostrado no código abaixo:

procedure TfrmConsCidade.btnPesquisarClick(Sender: TObject);
begin
  with dmDados.queConsCidade do
  begin
    Close;
    SQL.Clear;
    if (rgCampo.ItemIndex = 0) then
    begin
      // pidcidade é um parâmetro
      SQL.Add('select * from cidade where idcidade = :pidcidade');
      // atribuição do valor do parâmetro
      ParamByName('pidcidade').Value := StrToInt(edValor.Text);
      //Params[0].Value := StrToInt(edValor.Text);
    end
    else
    begin
      SQL.Add('select * from cidade where nome like :pnome');
      ParamByName('pnome').Value := edValor.Text + '%';
    end;
    Open;
  end;
end;

Em versões anteriores não havia o método ParamByName(). O acesso a um parâmetro era feito usando Params[]. Isso é mostrado na linha de código 13, que aparece comentada. O uso de ParamByName() torna o código mais legível.
O SQLdb melhorou muito, mas ainda aconselhamos o uso de ZeosLib.

Free Pascal - Variáveis Procedurais

Depois de um longo tempo afastado do blog, estamos retornando. Iremos iniciar uma série de artigos dedicados às estruturas de dados do Free Pascal. Mas antes de iniciar é necessário uma breve introdução a variáveis procedurais.
Variáveis procedurais ou tipos procedurais são um recurso do Free Pascal que permite armazenar métodos, funções e procedimentos em variáveis. Tais variáveis podem ser normalmente tratadas, passando-as como parâmetros e chamando os métodos quando for necessário.
Para exemplificar o uso deste recurso vejamos como declarar um tipo procedural:

type
  TFuncaoSemParametro = function(): String;
  TFuncaoComParametro = function(x: String): String;

O primeiro exemplo declara um tipo que armazena um função que não recebe argumentos. O segundo exemplo declara um tipo que armazena uma função que recebe parâmetros.
Tipos procedurais também podem ser declarados de mais duas maneiras, como pode ser visto abaixo. O primeiro declara um tipo para armazenar um procedimento e o segundo armazena um método de uma classe:

type
   TProcedimento = procedure;
   TMetodo = procedure of Object;

Prosseguindo então com nosso exemplo, em seguida iremos declarar as funções:

function AloMundo: String;
begin
  Result := 'Alo Mundo';
end;

function AloNovamente(S: String): String;
begin
  Result := 'Alo ' + S;
end;

Essas duas funções serão usadas como argumentos nas chamadas aos dois procedimentos seguintes, que recebem como parâmetros os tipos procedurais declarados.

procedure Primeiro(f: TFuncaoSemParametro);
begin
  WriteLn(f());
end;

procedure Segundo(f: TFuncaoComParametro);
begin
  WriteLn(f('Novamente'));
end;                 

Observe que tanto o procedimento Primeiro, quanto o procedimento Segundo executam a função que recebem como parâmetro. As funções chamadas irão retornar Strings que serão escritas no console através de writeln.
Para testar a funcionalidade apenas chame os procedimentos assim:

Primeiro(@AloMundo);
Segundo(@AloNovamente);

O símbolo @ converte a variável em um ponteiro. É desta forma que a função é passada como parâmetro.
É importante observar que o compilador verifica se a função ou o procedimento que está sendo passado como parâmetro corresponde exatamente ao esperado, ou seja, possui os mesmos parâmetros, o mesmo tipo de retorno, etc.
O mecanismo usado pelos eventos de componentes da biblioteca do Lazarus é exatamente este. Veja como pode ser criado um componente dinamicamente e como atribuir um método a um evento de um TButton no post Lazarus - Criando componentes em run-time.
A seguir o código completo da aplicação console:

program procvar;

{$mode objfpc}{$H+}

uses
  {$IFDEF UNIX}{$IFDEF UseCThreads}
  cthreads,
  {$ENDIF}{$ENDIF}
  Classes
  { you can add units after this };
type
  TFuncaoSemParametro = function(): String;
  TFuncaoComParametro = function(x: String): String;

function AloMundo: String;
begin
  Result := 'Alo Mundo';
end;

function AloNovamente(S: String): String;
begin
  Result := 'Alo ' + S;
end;

procedure Primeiro(f: TFuncaoSemParametro);
begin
  WriteLn(f());
end;

procedure Segundo(f: TFuncaoComParametro);
begin
  WriteLn(f('Novamente'));
end;

{$R *.res}

begin
  Primeiro(@AloMundo);
  Segundo(@AloNovamente);
  ReadLn;
end.

Atualizado em 03/05/2011.

Lazarus – Herança de form e criação de componentes em run-time

Neste post vamos mostrar como criar um formulário de cadastro, independente da tabela do banco de dados. A idéia é que, ao abrir o formulário, um trecho de código identifica cada campo da tabela, instancia um TDBEdit para esse campo e ainda o identifica com um TLabel. Além do mais esse código será implementado em um formulário pai. Cada formulário de cadastro será derivado – ou herdado – deste. Nosso demo terá um form principal que chamará o form de cadastro, o form pai onde todas as ações irão acontecer, um form de cadastro derivado e um Data Module.
No Data Module colocamos os componentes de acesso ao banco de dados. Para isso iremos utilizar ZeosLib com banco de dados PostgreSQL. Coloque então um TZConnection para conectar ao seu banco de dados e o configure adequadamente. Coloque também uma TZQuery e um TZUpdateSQL. Consulte o post Lazarus – Conectando PostgreSQL com ZeosLib se tiver dúvida de como fazer essas definições. Não coloque TDataSource no Data Module. Iremos colocá-lo no form pai.

O form Pai

Já existe um form na aplicação. Vamos inserir um novo form e deixar esse primeiro para ser o principal. No novo form vamos criar a propriedade Query conforme mostra o código abaixo. Inclua a unit ZDataset na cláusula uses.

private
    { private declarations }
    fQuery: TZQuery;
    function GetQuery: TZQuery;
    procedure SetQuery(NewQuery: TZQuery);
  public
    { public declarations }
    property Query: TZQuery read GetQuery write SetQuery;
  end;

var
  frmDinamico: TfrmDinamico;
  vetorCampos: array of TDBEdit;
  vetorLabel: array of TLabel;

implementation

{$R *.lfm}

procedure TfrmDinamico.FormShow(Sender: TObject);
var
   Coluna : integer;
   NomeColuna : TDBEdit;
   NomeLabel : TLabel;
   Topo : integer;
begin
   Topo := 65;
   dsTabela.DataSet := fQuery;
   fQuery.Open;
   SetLength(vetorCampos, fQuery.FieldCount);
   SetLength(vetorLabel, fQuery.FieldCount);
   for Coluna := 0 to fQuery.FieldCount - 1 do
   begin
     NomeColuna := TDBEdit.Create(Self);
     NomeColuna.Parent := Self;
     NomeColuna.Left := 105;
     NomeColuna.Top := Topo;
     NomeColuna.Width := 15 + fQuery.Fields[Coluna].DisplayWidth * 7;
     NomeColuna.DataSource := dsTabela;
     NomeColuna.DataField := fQuery.Fields[Coluna].FieldName;
     NomeColuna.Tag := Coluna;
     Topo := Topo + 25;
     NomeColuna.Visible := True;
     NomeColuna.Name := 'DBEdit' + IntToStr(Coluna);
     vetorCampos[Coluna] := NomeColuna;

     NomeLabel := TLabel.Create(Self);
     NomeLabel.Parent := Self;
     NomeLabel.Left := 5;
     NomeLabel.Top := NomeColuna.Top - NomeLabel.Height;
     NomeLabel.Caption := fQuery.Fields[Coluna].DisplayName;
     NomeLabel.Tag := Coluna;
     NomeLabel.Visible := True;
     NomeLabel.Name := 'Label' + IntToStr(Coluna);
     vetorLabel[Coluna] := NomeLabel;
   end;
   if Topo + 25 > 445 then
      Height := 445
   else
      Height := Topo + 25;

end;

procedure TfrmDinamico.FormClose(Sender: TObject; var CloseAction: TCloseAction
  );
begin
  fQuery.Close;
  CloseAction := caFree;
end;

function TfrmDinamico.GetQuery: TZQuery;
begin
  Result := fQuery;
end;

procedure TfrmDinamico.SetQuery(NewQuery: TZQuery);
begin
  fQuery := NewQuery;
end;

Implemente os métodos GetQuery e SetQuery conforme mostrado no código. Na seção var declaramos dois arrays dinâmicos para receber os objetos TDBEdit e TLabel. Agora vamos analisar com mais detalhes o código do evento OnShow. É nesse código que serão criados os objetos em tempo de execução, de acordo com os campos da tabela. No post Lazarus - Criando componentes em run-time nós mostramos como criar componentes em tempo de execução.
Inicialmente no método nós definimos o tamanho dos arrays de acordo com o número de campos da tabela usando o procedure SetLength. Em seguida, dentro de um for que percorre os campos da tabela, é criado um TDBEdit e um TLabel para cada campo. Cada componente é guardado em seu array correspondente. Depois disso é verificada a necessidade de se aumentar a altura do form para que ele possa mostrar todos os componentes criados. Essa verificação é feita através da variável Topo que guarda a posição vertical de cada componente. Como o nosso form é dinâmico, nós liberamos a memória ocupada por ele assim que o mesmo for fechado.

Herdando o form Pai

Depois disso vamos criar o form de cadastro propriamente dito. Para isso selecione o menu File | New e clique em Inherited Component. Na caixa da direita irão aparecer os forms que podem ser herdados. Escolha o form Pai que foi criado anteriormente e pressione OK. Um novo form será criado com todos os membros do form Pai. Agora selecione a opção de menu Project | Project Options. Clique em Forms e transfira o form Filho para a caixa da direita. Isso determina que o form Filho será instanciado em tempo de execução. Para que tudo funcione perfeitamente no form Filho, devemos implementar os métodos herdados e informar a palavra chave inherited. No nosso caso precisamos implementar apenas os método dos eventos OnShow e OnClose, como mostra o código abaixo.

procedure TfrmCidade.FormShow(Sender: TObject);
begin
   inherited
end;

procedure TfrmCidade.FormClose(Sender: TObject; var CloseAction: TCloseAction);
begin
   inherited
end;            

Para testar nosso demo, vamos ao form principal. Coloque um botão e escreva o seguinte código no evento OnClick.

if TfrmCidade(Application.FindComponent('frmCidade')) = nil then
  frmCidade := TfrmCidade.Create(Application);
frmCidade.Query := dmDados.queCidade;
frmCidade.Show;

Estamos supondo que o nome do form Filho é frmCidade, que o nome do Data Module é dmDados e que a TZQuery no Data Module chama-se queCidade. Pronto você pode executar o programa e pressionar o botão. Você terá uma tela assim:

Você pode agora repetir esse procedimento para todas as tabelas que precisem de formulários de cadastro. Bem, certamente não é um form de cadastro perfeito, pois todos os campos são definidos com TDBEdit, mas a partir daqui você pode tentar vôos mais altos.

Lazarus - AutoCommit no ZeosLib com PostgreSQL

Por padrão, o PostgreSQL trata cada comando SQL como sendo executado dentro de uma transação. Ou seja, cada comando DML (INSERT, UPDATE ou DELETE) tem um comando de início de transação (BEGIN) e um comando COMMIT – caso seja bem sucedido – executados implicitamente antes e depois. Para a execução de múltiplos comandos DML isso leva a um overhead. Desta forma, sugere-se fortemente envolver todos os comandos DML em uma única transação – se a lógica da sua aplicação permitir. Para demonstrar esta recomendação fizemos um teste simples. Escrevemos um pequeno programa para inserir 5.000 linhas em uma tabela. Primeiro fizemos o teste com o controle de transação padrão - cada uma das 5.000 linhas tem seu próprio BEGIN e COMMIT - e depois modificamos o código para controlar a transação manualmente. Neste último teste todas as 5.000 linhas são inseridas dentro de uma única transação.
Para nosso teste usamos ZeosLib. Por padrão o ZeosLib também opera no modo Auto-Commit, ou seja, cada comando é executado no contexto de uma transação. Não mostraremos aqui como conectar ao PG usando Zeos, pois isso já foi apresentado no post Lazarus - Conectando PostgreSQL com ZeosLib. Vejamos o primeiro teste. A unit Dateutils deve ser incluida na cláusula uses para poder usar a função
MilliSecondsBetween(). dbBanco é um ZConnection, dmDados é um Data Module e queCidade uma ZQuery.

var
  i: integer;
  a, b: TDateTime;
begin
  dmDados.queCidade.SQL.Clear;
  dmDados.queCidade.SQL.Add('insert into cidade values (:id, :nome)');
  a := time;
  for i := 1 to 5000 do
  begin
    dmDados.queCidade.ParamByName('ID').Value:= i;
    dmDados.queCidade.ParamByName('NOME').Value:='SANTAREM';
    dmDados.queCidade.ExecSql;
  end;
  b := time;
  ShowMessage(IntToStr(MilliSecondsBetween(b,a)));
end;

Neste primeiro código o tempo médio de inserção das 5.000 linhas foi de 11,6 segundos. Alteramos então nosso código para que todas as linhas fossem inseridas dentro de uma única transação. Para isso chamamos StartTransaction antes de iniciar os INSERTs. Observe o código abaixo.

var
  i: integer;
  a, b: TDateTime;
begin
  a := time;
  dmDados.queCidade.SQL.Clear;
  dmDados.queCidade.SQL.Add('insert into cidade values (:id, :nome)');
  dmDados.dbBanco.StartTransaction;
  for i := 1 to 5000 do
  begin
    dmDados.queCidade.ParamByName('ID').Value:= i;
    dmDados.queCidade.ParamByName('NOME').Value:='SANTAREM';
    dmDados.queCidade.ExecSql;
  end;
  dmDados.dbBanco.Commit;
  b := time;
  ShowMessage(IntToStr(MilliSecondsBetween(b,a)));
end;

Neste caso o tempo médio de execução do código foi de 2,9 segundos. Um ganho de tempo considerável em relação à execução em modo padrão.
Fizemos também um teste usando TZUpdateSQL, implementado de acordo com o post citado acima. O código é apresentado em seguida e o tempo médio de execução foi de 3,8 segundos. Um desempenho um pouco pior do que o teste anterior.

var
  i: integer;
  a, b: TDateTime;
begin
  a := time;
  dmDados.queCidade.Open;
  dmDados.dbBanco.StartTransaction;
  for i := 1 to 5000 do
  begin
    dmDados.queCidade.Insert;
    dmDados.queCidade.FieldByName('ID').Value := i;
    dmDados.queCidade.FieldByName('NOME').Value:='SANTAREM';
    dmDados.queCidade.Post;;
  end;
  dmDados.dbBanco.Commit;
  b := time;
  ShowMessage(IntToStr(MilliSecondsBetween(b,a)));
end;

Estes teste foram feitos em Windows e servidor de BD e cliente rodando na mesma máquina. Certamente se você executar esses testes em outro ambiente, os tempos serão diferentes, mas comparativamente você deverá chegar à mesma conclusão.
Sabe-se que uma falha no sistema, enquanto uma transação estiver ativa, causa a execução de um ROLLBACK pelo SGBD, fazendo com que todas as atualizações feitas a partir do BEGIN sejam canceladas. Portanto, use esta recomendação com cautela e bom senso. Longas transações ativas estão sujeitas a perdas de dados muito maiores que transações curtas, em caso de falhas no sistema.

Atualizado em 28/09/2010.

Lazarus - Aplicação WinCE usando tabelas DBF

Há algum tempo eu escrevi um artigo aqui no blog chamado Lazarus - Criando uma aplicação para WinCE. Nesse artigo usei SQLite para WinCE. E a implementação tinha bastante código pois usava a unit sqlite3ds. Agora vou mostrar que é possível desenvolver usando tabelas Dbase, aquelas que tem a extensão DBF. Para isso vamos usar o componente TDbf da aba Data Access. A seguir os passos necessários:

1) Crie uma tabela Dbase.
2) Inicie uma nova aplicação e coloque um TDbf no DataModule. Na propriedade TableName localize a tabela que foi criada.
3) Nas propriedades FilePath e FilePathFull ele vai automaticamente definir o caminho do PC onde está a tabela. Depois vamos resolver isso.
4) Coloque um TDataSource no Data Module e faça a associação necessária com o TDbf.
5) Agora vamos ao form da interface e coloque os controles (da aba Data Controls) necessários para cada campo da tabela. Associe a propriedade DataSource de cada controle com o DataSource inserido no passo 4. Na propriedade DataField você pode digitar o nome do campo da tabela DBF ou, se a tabela estiver ativa, selecionar na caixa combinada. Lembre que neste form deve ser incluida a linha uses referente a unit do Data Module.
6) Coloque um TDBNavigator e ligue a propriedade DataSource adequadamente.
7) No evento OnShow do form digite o seguinte:

dbf1.FilePath := '';

dbf1.FilePathFull := '';

dbf1.Open;

Se você tiver mudado a propriedade Name do TDbf, substitua o dbf1 no código acima pelo nome que você escolheu.
Para compilar um projeto WinCE é necessário fazer algumas configurações em Project -> Project options. Na opção Paths abaixo de Compiler Options selecione wince em LCL Widget Type (various). Na opção Code generation escolha WinCE em Target OS (-T) e arm em Target CPU family (-P). Pronto. O compilador irá gerar um executável que executa apenas no PDA. Dessa forma para compilar use sempre CTRL + F9. Nos testes eu usei o Lazarus 0.9.29. Se você utiliza a versão 0.9.28 o caminho para essas configurações está em Project -> Compiler options.
Copie o executável e a tabela para o PDA e execute. Pronto, simples assim. Fiz testes com sucesso em um PDA com WM 5 e no emulador WM 6.

Lazarus - Relatório Mestre detalhe com LazReport

Neste post iremos mostrar como criar um relatório mestre detalhe usando o componente LazReport. No artigo Lazarus - Criando relatórios com FortesReport (Parte I) mostramos como instalar o LazReport. Para o exemplo que será criado aqui usaremos o banco de dados Firebird e o conjunto de componentes ZeosLib. Use o seguinte script para criar as tabelas.

O Data Module

Inicie uma aplicação no Lazarus e insira um Data Module. Selecione a aba Zeos Access e coloque um TZConnection no Data Module. Defina as propriedades da seguinte forma:

Database - informe o banco de dados Firebird que foi criado.
Name - dê um nome ao componente. Por exemplo: dbVendas.
Password - masterkey.
Protocol - firebird-2.0 ou a versão que está sendo usada.
User - sysdba.

Mude Connected para true, para verificar se a conexão está configurada corretamente.
Coloque um TZReadOnlyQuery e defina:

Connection - selecione o TZConnection.
Name - defina um nome para o componente. Por exemplo: queVenda.
SQL - select a.id_venda, a.data_venda, b.nome from venda a, cliente b where a.id_cliente = b.id_cliente.

Selecione a aba Data Access e coloque um TDataSource, onde DataSet deve estar associado à Query anterior. Defina Name como dsVenda.

Coloque um segundo TZReadOnlyQuery, defina Connection da mesma maneira e em Name digite queItem, por exemplo. Na propriedade SQL informe select a.id_produto, b.nome, a.quantidade, b.preco_venda, a.quantidade * b.preco_venda total from item a, produto b where a.id_produto = b.id_produto and id_venda = :id_venda.

Defina a propriedade DataSource desta Query com dsVenda. Isto, juntamente com o parâmetro :id_venda definem o relacionamento mestre detalhe entre as duas Queries. O parâmetro :id_venda é definido por queVenda através de dsVenda.

Coloque mais um TDataSource e defina a propriedade DataSet com a Query queItem. Defina Name como dsItem. Salve o Data Module e chame a unit de u_dmdados. Leia mais para conexão com Firebird em Lazarus - Conectando Firebird com SQLdb ou ZeosLib.

O relatório

No form onde será criado o relatório digite logo abaixo de Implementation a linha uses u_dmdados. Localize a aba LazReport e coloque um TfrDBDataSet e defina sua propriedade DataSource como dsVenda, e na propriedade Name digite frDBVenda. Coloque outro TfrDBDataSet e defina sua propriedade DataSource como dsItem, e na propriedade Name digite frDBVenda. Coloque um TfrReport e, na propriedade DataSet informe frDBVenda. Agora coloque um TfrDesigner. Dê um duplo clique no frReport. A seguinte tela deverá aparecer:

Este é o designer do LazReport. Insira uma banda e escolha o tipo Page Header. Coloque um objeto Text e informe o título do cabeçalho, por exemplo, Relação de Vendas. Escolha um tamanho de fonte e centralize o objeto adequadamente na banda.
Insira nova banda e escolha o tipo Master Data. Ele vai abrir uma janela solicitando a escolha de um DataSet. Escolha frDBVenda.

Insira objetos Text de forma que a banda fique como na figura acima. Em um objeto Text é possível digitar um texto, informar uma variável ou um campo de tabela. Do DataSet frDBVenda, informamos o ID, a DATA e o NOME do cliente. Os objetos restantes são todos textos.
Insira outra banda e escolha o tipo Detail Data. Escolha o DataSet frDBItem. Coloque cinco objetos Text e informe os campos ID_PRODUTO, NOME, QUANTIDADE, PRECO_VENDA e TOTAL. Para formatar PRECO_VENDA e TOTAL informe Text da seguinte forma:

[dmDados.zqItem."PRECO_VENDA" #N##,##0.00]

Insira nova banda e selecione o tipo Detail Footer. Coloque dois objetos Text. Em um deles informe Total da venda: No segundo digite:

[SUM([dmDados.zqItem."TOTAL"]) #N##,##0.00]

Esse campo somará o total da venda e o mostrará formatado. Salve o relatório. Dê a ele o nome venda.lrf, por exemplo. Feche e volte ao form. Coloque dois botões. Em um deles digite Editar no Caption. Dê um duplo clique nele e digite no editor de código:

frVenda.LoadFromFile('vendas.lrf');
frVenda.DesignReport;

Esse botão permitirá alterar o desenho do relatório. No segundo botão digite Preview no Caption. Dê um duplo clique e digite no editor de código:

frVenda.LoadFromFile('vendas.lrf');
frVenda.ShowReport;

Este é o botão que visualizará o relatório na tela, conforme mostra a figura a seguir:

Lazarus - Dicas de LazReport

Neste post vou apresentar algumas dicas para criar relatórios com mais eficiência em LazReport. No post Lazarus - Criando relatórios com FortesReport (Parte I) eu mostrei como instalar o LazReport e o link para um tutorial que ensina passo a passo como criar um relatório.

Exportando um relatório para PDF

Esse é um procedimento bastante simples, mas é necessário instalar dois pacotes. Para exportar um relatório para PDF você precisa do LazReportPDFExport. Este componente está em source\addons\pdfexport no mesmo diretório do LazReport. Mas este componente depende do PowerPDF. Você pode fazer o download do pacote PowerPDF no repositório de componentes e código Lazarus. Instale o PowerPDF e depois o LazReportPDFExport. O PowerPDF irá aparecer em uma nova aba de componentes e o LazReportPDFExport será um novo componente -TfrTNPDFExport - na aba do LazReport.
Supondo que você já criou o relatório, coloque um TfrTNPDFExport no mesmo form onde está o TfrReport. Execute o seu programa e visualize o relatório. Clique no botão Save report. Clique na caixa Tipo e deve aparecer a opção Adobe Acrobat PDF (*.pdf). Selecione esta opção, dê um nome ao arquivo e pressione o botão Salvar. Agora você tem um arquivo pdf com o seu relatório. Também existem componentes que permitem você exportar para HTML ou CSV.

Object Inspector

Semelhante ao Object Inspector do Lazarus, com ele podemos manipular propriedades de alguns objetos, tais como: nome, posição, tamanho e visibilidade. No LazReport ele é tratado como uma ToolBar. Pode ser mostrado ou ocultado. Para mostrar a janela do Object Inspector selecione Tools -> ToolBars -> Object Inspector. Depois simplesmente selecione um objeto no relatório para visualizar/alterar suas propriedades.

Destacando objetos

Em certos relatórios pode ser necessário mudar a cor da fonte e/ou do fundo de objetos, baseado em certas condições. Para isso selecione o objeto alvo e pressione o botão Highlight attributes na barra de ferramentas de formatação de texto, como mostra a figura abaixo.

Vamos supor que tenhamos um relatório de vendas mensais efetuadas pelos vendedores de uma loja e que a meta para aquele mês seja 10.000 reais. Então, queremos que os valores abaixo de 10.000 apareçam com fonte em vermelho. Na caixa de texto Condition da janela Highlight attributes informe Value < 10000. Selecione a cor da fonte e/ou a cor de fundo e pressione o botão OK. Veja a figura seguinte. Agora o relatório irá mostrar os valores de venda menores que 10.000 em vermelho. Condições mais complexas podem ser criadas usando o recurso de script que será apresentado mais adiante.

Programando eventos

Em certos casos pode ser necessário imprimir dados que não estão em bancos de dados. Uma opção é usar os eventos do componentes TfrReport. Dois desses eventos são OnGetValue e OnEnterRect. OnGetValue ocorre toda vez que um objeto Text encontra uma variável e precisa atribuir um valor a ela. Se a variável não possuir um valor então esse valor é definido através de código, por exemplo:

procedure TForm1.frReport1GetValue(const ParName: String; var ParValue: Variant);
begin
  if ParName = 'Variavel1' then
     ParValue := 100;
end;

Onde ParName tem o nome da variável como string e ParValue recebe o valor dessa variável. Por sua vez o evento OnEnterRect acontece antes que um objeto seja desenhado. Podemos, por exemplo, imprimir um dado bem específico em uma linha ou coluna do relatório.

procedure TForm1.frReport1EnterRect(Memo: TStringList; View: TfrView);
begin
  if (FCol=3)and(FRow=3) then
    view.Memo.Text := 'ALO';
end;

FCol e FRow definem uma coluna e uma linha do relatório respectivamente. No exemplo será impressa a palava ALO na linha 3 e coluna 3.

Programando um script

LazReport possui um interpretador interno semelhante ao Pascal que tem as seguintes características:

• Operador de atribuição (:=);
• Estruturas if ... then ... else, while ... do e repeat ... until;
• Delimitadores de blocos begin e end;
• Variávies não tipadas;
• Acesso aos objetos do LazReport e suas propriedades.

Sempre que um objeto ou banda for impresso, o script associado a ele é executado. O editor de script é acessível no editor memo sempre que a caixa Script estiver marcada. Para visualizar o editor memo de um objeto como Text, por exemplo, basta dar um duplo clique nele. Em uma banda tecle CTRL + ENTER. Veja o editor memo abaixo com o editor de script habilitado.

Algumas propriedades de objetos visuais que podem ser usadas nos scripts são:

Visible - determina a visibilidade do objeto (boolean);
FillColor - determina a cor de fundo do objeto. Valores possíveis: clRed, clBlue, etc.;
Text - conteúdo do memo;

Objetos Text tem também as seguintes propriedades:

FontName, FontSize, FontColor - nome, tamanho e cor da fonte;
FontStyle - estilo da fonte (1 - itálico, 2 - negrito e 3 - sublinhado);
Adjust - alinhamento do texto (1 - direita, 2 - centro).

Por exemplo, voltando ao nosso relatório de vendas, vamos supor que queremos imprimir em verde os valores acima do dobro da meta, em vermelho os valores abaixo da meta e em azul os demais. O código ficaria como abaixo, supondo que o valor seja dado por [TotalVendas]:

if [TotalVendas] < 10000 then 

   FontColor := clGreen 

else if [TotalVendas] < 20000 then 

   FontColor := clBlue 

else 

   FontColor := clRed;

Vamos continuar explorando os recursos do LazReport. No próximo post vamos mostrar como criar um relatório mestre-detalhe.

Java - Strings, memória e imutabilidade

O entendimento sobre pilha e heap pode facilitar em muuito a compreensão de temas como passagem de parâmetros, polimorfismo, garbage collector, etc. Mas neste post darei apenas uma rápida visão para poder falar o assunto principal que é a forma como Java trata os objetos String.
Em geral, variáveis de instância, objetos e arrays - que também são objetos - residem no heap. Já as variáveis locais, tanto de tipos primitivos quanto as referências, residem na pilha.
Sabemos que uma String pode ser instanciada de várias maneiras, como nestes exemplos:

String s = new String("abcd");   // ou

s = "abcd";

Para que o uso da memória seja mais eficiente em Java, a JVM mantém uma área especial de memória chamada pool de Strings constantes. Quando o compilador encontra um literal String, ele verifica se existe uma String idêntica no pool. Se existir, a referência ao novo literal é direcionada à String existente e não é criado novo objeto String. Mas quando um objeto String é criado usando new, por exemplo:

String s = new String("abc"));

Esse novo objeto é criado no heap - a memória onde residem todos os objetos em Java - e "abc" é inserida no pool de Strings constantes, se não existir.. Além disso, as Strings são imutáveis. Por exemplo:

String s = "abc";
s.concat("def"); // concatena o argumento ("def") à String "abc"

Nesse momento Java cria uma nova String com o valor "abcdef", mas ela fica perdida na memória, pois a variável s não muda seu valor e continua valendo "abc". No entanto se a segunda linha for alterada para:

s = s.concat("def");

Então s passará a valer "abcdef". A variável s será uma nova String. A String "abc" fica perdida na memória. Ou seja, se o resultado da expressão não for atribuido a uma variável seu valor será perdido. Analise esse código:

String s1 = "abc";
String s2 = "abc";
String s3 = "abc";
s3 = s3.concat("def");
System.out.println(s1 + " " + s2 + " " + s3);

Inicialmente as Strings s1, s2, s3 referem-se ao mesmo objeto no pool, pelo que foi exposto acima.  No entanto, diferente do que possamos pensar, quando criamos um novo objeto e o referenciamos com s3, os valores de s1 e s2 não se alteram pelo princípio da imutabilidade.
A classe StringBuffer se comporta de forma diferente. Ela não é imutável.

String sb1 = new StringBuffer("abc");
String sb2 = new StringBuffer("abc");
String sb3 = new StringBuffer("abc");
sb3.concat("def");
System.out.println(sb1 + " " + sb2 + " " + sb3);


Mesmo o código acima produzindo o mesmo resultado do código usando String, a explicação é que sb1, sb2 e sb3 são três objetos diferentes. Observe que este código produz algo diferente, pois agora só existe um objeto e três referências:

StringBuffer sb1 = new StringBuffer("abc");
StringBuffer sb2 = sb1;
StringBuffer sb3 = sb2;
sb3.append("def");
System.out.println(sb1 + " " + sb2 + " " + sb3);

Espero que o comportamento de Strings em Java tenha ficado mais claro para você. Leia mais sobre strings no tutorial sobre strings no site da Sun.

Lazarus - Conectando Oracle com SQLdb ou ZeosLib

A Oracle oferece uma versão free do Oracle Database 10g. É o Oracle Database 10g Express Edition. Utilizamos esta versão neste artigo. Além disso, utilizamos a versão 0.9.29 do Lazarus, Free Pascal 2.4.1 e ZeosLib 7.0.0.
Para os testes usamos o usuário do Oracle hr, que é criado em uma nova instalação. Depois de instalado o banco de dados, o usuário hr deve ser desbloqueado pelo DBA e definida uma senha. Esse usuário tem acesso às tabelas do schema hr, também instalado junto com o banco. No entanto criamos uma nova tabela para os testes, de forma a manter as tabelas originais inalteradas. Criamos então nossa famosa tabela CIDADE.

CREATE TABLE  "CIDADE" 
   ( "ID_CIDADE" NUMBER NOT NULL ENABLE, 
 "NOME" VARCHAR2(40), 
  CONSTRAINT "CIDADE_PK" PRIMARY KEY ("ID_CIDADE") ENABLE
   )

Existe ferramenta de administração visual na instalação do Oracle, mas não é objetivo deste artigo expor a utilização da mesma.

Conexão com SQLdb

Para fazer a conexão vamos usar como sempre um Data Module onde os componentes de banco de dados serão colocados.

Localize na aba SQLdb o componente TOracleConnection e coloque no Data Module. Defina suas propriedades como segue:

DatabaseName - informe aqui o SID do banco de dados. No nosso caso é XE, o SID do Oracle Database Express Edition.
Hostname - informe o nome ou IP da máquina onde está o servidor do banco de dados. Como meu teste foi feito na máquina onde está o servidor, eu informei localhost, ou poderia ter informado 127.0.0.1.
Password - informe a senha do usuário hr. Ou de qualquer usuário com acesso ao banco de dados.
UserName - informe hr, ou outro usuário com acesso ao banco de dados.
Para fazer um teste na conexão, mude a propriedade Connected para True. Depois volte para False.

Coloque um TSQLTransaction e defina a propriedade Database com o nome do TOracleConnection que foi colocado anteriormente.

Coloque um TSQLQuery. Defina suas propriedades como mostrado a seguir:

Database - selecione o TOracleConnection anterior.
SQL - informe SELECT * FROM CIDADE.

Finalize colocando um TDataSource da aba Data Access. Defina a propriedade DataSet com a SQLQuery colocada antes.
No evento AfterPost da TSQLQuery digite o código:

SQLQuery1.ApplyUpdates;
SQLTransaction1.CommitRetaining;

No evento AfterDelete selecione o mesmo método para não repetir código.
Pronto. Está feita a configuração de acesso, tanto para leitura quanto para escrita, em uma tabela do Oracle. Crie uma interface seguindo os passos descritos no post Lazarus - Acessando banco de dados com SQLdb - Parte I.
Lembre de abrir a conexão. Pode ser no evento OnCreate do Data Module, com o código:

OracleConnection1.Open;

Conexão com ZeosLib

Coloque um TZConnection no Data Module. Defina as propriedades:

AutoCommit - deixe em True para que as transações no banco sejam comitadas automaticamente.
Database - informe o nome ou IP da máquina do servidor do banco de dados, por exemplo: localhost se estiver na mesma máquina.
HostName - informe o SID do banco de dados. XE no nosso caso. Observe que as propriedades HostName e Database são informadas de forma invertida em relação ao SQLdb.
Password - informe a senha do usuário com acesso ao banco. Neste caso foi usado hr.
Protocol - informe oracle ou oracle-9i. Ambos funcionam.
User - informe o nome do usuário. Neste caso é hr.

Mude Connected para True para testar a conexão. Depois de conectar com sucesso volte Connected para False.

Coloque um TZQuery e um TZUpdateSQL e configure-os como foi feito no artigo Lazarus - Conectando PostegreSQL com ZeosLib.
No TZUpdateSQL defina essas propriedades assim:

DeleteSQL - DELETE FROM CIDADE WHERE ID_CIDADE = :OLD_ID_CIDADE;
InsertSQL - INSERT INTO CIDADE VALUES (:ID_CIDADE, :NOME);
ModifySQL - UPDATE CIDADE SET NOME = :NOME WHERE ID_CIDADE = :OLD_ID_CIDADE;


Coloque um TDataSource da aba Data Access e na propriedade DataSet selecione a TZQuery anterior. Está pronta nossa conexão e acesso a uma tabela. Agora crie a interface com nos posts anteriores. Não esqueça de abrir a conexão com o comando:

ZConnection1.Connect;

Pode ser no evento OnCreate do Data Module.

Tipos de dados no SQLite

Em SQLite, diferente de outros motores de banco de dados, o tipo de dado de um valor está associado com o valor propriamente dito, e não com o seu contêiner. É um sistema de tipo dinâmico. Um campo de uma tabela em SQLite pode receber qualquer tipo de dado. Assim, o SQLite simplesmente ignora o tipo informado no comando CREATE TABLE.
Então, dizemos que no SQLite existem classes de armazenamento. E essas classes são:

NULL - como em qualquer outro banco de dados.
INTEGER - inteiro com sinal, armazenado em 1, 2, 3, 4, 6 ou 8 bytes dependendo da grandeza do valor.
REAL - valor de ponto flutuante armazenado em 8 bytes.
TEXT - uma string armazenada usando UTF-8, UTF-16BE ou UTF-16LE.
BLOB - armazena um blob, como indica o nome.

Uma coluna INTEGER PRIMARY é uma exceção. Só aceita números inteiros. Qualquer valor em um comando SQL tem uma classe de armazenamento implícita. Durante a execução do comando SQL, o SQLite pode converter valores entre classes numéricas (INTEGER e REAL) e TEXT.

Tipo Boolean

Não existe uma classe Boolean. Pode-se considerar os inteiros 0 (false) e 1 (true).

Tipos Data e Hora

Não existem classes de armazenamento para armazenar data e/ou hora. Existem funções capazes de tratar TEXT, REAL ou INTEGER como data e hora:

TEXT - como string ISO8601 ("YYYY-MM-DD HH:MM:SS.SSS").
REAL - como dias Julianos. A origem (dia 0) é o meio dia de 24 de novembro de 4714 A.C., pelo calendário Gregoriano.
INTEGER - como a hora no Unix. A origem é o dia 1º de janeiro de 1970.

Funções de Data e Hora

São cinco as funções:

date(timestring, modifier, modifier, ...) - retorna a data no formato YYYY-MM-DD.
time(timestring, modifier, modifier, ...) - retorna a hora no formato HH:MM:SS.
datetime(timestring, modifier, modifier, ...) - retorna data e hora no formato "YYYY-MM-DD HH:MM:SS".
julianday(timestring, modifier, modifier, ...) - retorna do dia Juliano.
strftime(format, timestring, modifier, modifier, ...) - retorna a data formatada de acordo com o formato especificado no primeiro argumento.

Todas recebem uma string de tempo e 0 ou mais modificadores como argumentos. Uma string de tempo pode ter um dos seguintes formatos, além de outros que podem ser encontrados em http://www.sqlite.org/lang_datefunc.html:

YYYY-MM-DD
YYYY-MM-DD HH:MM:SS
HH:MM
HH:MM:SS
now

O formato 'now' é convertido na data e hora correntes. Por exemplo:

SELECT date('now'); - calcula da data corrente.

Os modificadores alteram a string de data e hora. Alguns dos modificadores disponíveis são:

NNN days
NNN hours
NNN minutes
NNN.NNNN seconds
NNN months
NNN years
start of month
start of year

Os primeiros seis modificadores simplesmentes adicionam a quantidade de tempo especificada à data e hora especificadas pela string de tempo. Por exemplo:

SELECT date('now', '+1 days'); - calcula a data corrente mais um dia.
SELECT date('now', 'start of month'); - calcula o primeiro dia do mês corrente.

O parâmetro formato pode assumir alguns desses valores:

%d - dia do mês
%H - hora (de 00 a 24)
%J - dia Juliano
%w - dia da semana de 0 a 6 (domingo = 0)

Por exemplo:

SELECT strftime('%J', 'now'); - calcula o dia Juliano equivalente à data corrente.

Este post foi baseado no texto original em inglês em http://www.sqlite.org/datatype3.html.

Lazarus - Aplicação embarcada com Firebird e ZeosLib

Uma aplicação embarcada, ou embutida, com Firebird é uma aplicação que não necessita do servidor de banco de dados para executar. É uma solução excelente para criar demos de programas, criar um catálogo de produtos em CD, entre outras aplicações. Resumidamente, o motor do Firebird embedded está em uma dll.
A versão embedded do Firebird executa apenas em modo local, não reconhecendo nem mesmo localhost. Ela ignora qualquer instância do Firebird executando na mesma máquina. Procure usar sempre o usuário SYSDBA para a conexão com o banco. Como não existe a figura de um servidor de banco de dados, você poder rodar quantas aplicações forem necessárias. Cada uma será uma instância diferente. Tudo depende da memória da máquina.

Instalação do Firebird

O primeiro passo consiste em fazer o download da versão embarcada do Firebird. Escolha a versão e a plataforma desejada em http://www.firebirdsql.org/index.php?op=files. Vamos mostrar aqui apenas o procedimento para o ambiente Windows. Você deve baixar a versão embedded. Por exemplo, se optar pela versão 2.1.3, você pode baixar este zip. Depois disso, crie um diretório (p.ex. C:\MeuPrograma) onde ficará sua aplicação e descompacte o zip que você baixou dentro dele. Esse diretório será o home do Firebird embutido. O banco de dados deve ficar nesse mesmo diretório. Em seguida faça o seguinte:
1) Edite o arquivo firebird.conf e modifique a seguinte linha para ficar assim:

RootDirectory = C:\MeuPrograma

2) Altere o nome do arquivo fbembed.dll para fbclient.dll, se você for usar o ZeosLib. Se for usar o SQLdb, renomeie para gds32.dll.

Se sua aplicação utilizar UDFs, copie-as para o diretório UDF. Collates e charsets devem ser copiados para o diretório INTL.

Conectando ao banco de dados com ZeosLib

Coloque um TZConnection no Data Module. Defina as seguintes propriedades assim:

Database - informe apenas o nome do arquivo do banco de dados.
HostName - deixe em branco.
Name - dbEmbutido, por exemplo.
Password - masterkey.
Protocol - firebird-2.0.
User - sysdba.

Não tente conectar ao banco em tempo de desenvolvimento. Não irá conectar. Escreva o seguinte código no evento OnCreate do Data Module:

dbEmbutido.Connect;

Os outros procedimentos são exatamente os mesmos de uma conexão normal como mostramos em Lazarus - Conectando Firebird com ZeosLib ou SQLdb. Para construir uma interface leia os posts Lazarus - Acessando banco de dados com SQLdb - Parte I e Parte II.Se preferir usar SQLdb para embarcar sua aplicação siga exatamente o mesmo procedimento do post anterior. Só lembre de renomear fbembed.dll para gds32.dll.

Atualizado em 23/05/2010.

Lazarus - Criando componentes em run-time

A primeira pergunta que alguém pode fazer é "Por que eu preciso criar componentes em tempo de execução?" Posso dar vários motivos e vou citar apenas dois. Primeiro: suponhamos que você permita que o usuário do seu sistema crie novos campos em um tabela. Para que ele possa usar esses novos campos são necessários novos componentes no form, correto? Segundo: eu quero criar um relatório genérico que possa imprimir dados de qualquer tabela. Apenas em tempo de execução eu irei saber quais e quantos componentes eu irei usar nesses casos. Então vamos à prática. Para nosso exemplo irei criar um botão da classe TButton. Mas poderia ser qualquer componente que você precise criar.

Criando um TButton em tempo de execução

A primeira coisa a fazer é declarar uma variável para o botão, por exemplo:

Botao: TButton;

Pode ser necessário incluir a unit StdCtrls. Em seguida escrevemos o código que cria o componente:

Botao := TButton.Create(nil);

O construtor Create espera receber o dono do componente (Owner) como parâmetro. Nesse caso informamos que o Botão não tem dono. Você pode ainda informar Self ou Application. Se for informado um desses dois últimos, o objeto criado será destruído juntamente com o seu dono. No nosso exemplo o objeto deve ser destruído explicitamente usando o método Free.

Quando um objeto é criado, muitas propriedades recebem valores padrão. Dessa forma precisamos definir pouca coisa mais.

Botao.Parent := Form1;
Botao.Name := 'Botao';
Botao.Caption :='Ok';

A propriedade Parent informa onde o componente será colocado. Ou seja Parent indica o componente que contém o botão. Se tivermos um TPanel chamado Panel1 dentro do Form1 e desejarmos inserir o botão nesse painel, só precisamos informar Botao.Parent := Panel1. Podemos definir valores para as propriedades Left e Top do botão. Esses valores são sempre relativos ao Parent. Ambas serão inicializadas com 0, caso não atribuirmos valores para elas.
Se desejarmos definir um método para um evento do componente, é necessário criar o método primeiro. Por exemplo, supondo que queremos programar o evento OnClick do botão:

procedure TForm1.Clica(Sender: TObject);

begin

   ShowMessage('Componente dinâmico');

end;

Assim, podemos referenciar o método durante a criação do componente com o comando:

Botao.OnClick := @Clica;

Para liberar a memória quando não precisarmos mais do componente usamos o seguinte comando, que pode ser colocado no evento OnClose do form.

Botao.Free;

Um novo item de menu

Para incluir um novo item de menu, vamos supor que já exista um TPopupMenu chamado PopupMenu1. Declaramos um novo TMenuItem:

ItemNovo: TMenuItem;

E o código para cirar o novo item:

ItemNovo := TMenuItem.Create(nil);

ItemNovo.Caption := 'Nova opção';

ItemNovo.Name := 'ItemNovo';

ItemNovo.OnClick := @Clica;

PopupMenu1.Items.Add(ItemNovo);

Agora, resta exceutar o programa e experimentar nossos componentes dinâmicos.

Atualizado em 16/05/2010.

Lazarus - Conectando MySQL com SQLdb ou ZeosLib

Vamos mostrar duas maneiras de acessar MySQL no Lazarus. Uma usando os componentes nativos SQLdb e outra usando ZeosLib. Utilizamos no exemplo a versão 5.1.46 do MySQL. O SQLdb da versão 0.9.28.2 não funciona com essa versão do MySQL. Dessa forma, foi instalado o snapshot Lazarus-0.9.29-25198-fpc-2.4.1-20100505-win32.exe (usamos o Windows XP nos testes). Snapshots são builds noturnos do Lazarus compilados com os últimos códigos fonte, corrigindo alguns erros e provavelmente introduzindo outros.

Crie o banco dados no MySQL. Vamos usar o mesmo banco usado em artigos anteriores. Este é o script de criação das tabelas:

create table cidade (id_cidade int not null primary key, nome varchar(30));

create table cliente (id_cliente int not null primary key, nome varchar(40), endereco varchar(40), id_cidade integer references cidade(id_cidade), telefone varchar(14), tipo char(1));

Usando SQLdb

Selecione a aba SQLdb e coloque no Data Module um TMySQL50Connection. Ele que fará a conexão com o banco. Defina então as seguintes propriedades:

DatabaseName - informe o nome do banco de dados que foi criado.
HostName - informe o nome ou o IP do servidor de banco de dados.
Name - informe um nome para a conexão. Por exemplo: dbCliente.
Password - informe a senha do usuário. Se usar root como nome de usuário, informe a senha definida no momento da instalação do MySQL.

UserName - informe o nome do usuário. Pode ser o root.

Coloque agora um TSQLTransaction e selecione dbCliente na propriedade Database, e na propriedade Name digite trCliente, por exemplo.
Volte ao TMySQL50Connection e informe trCliente na propriedade Transaction. Coloque a propriedade Connected em True para verificar se a conexão é feita. Se retornar uma mensagem de falta da dll libmySQL, localize a mesma no diretório bin do MySQL e copie-a para o diretório system32. Depois volte a propriedade para False.
Coloque um TSQLQuery no Data Module e defina suas propriedades:

Database - selecione dbCliente.
Name - defina queCidade.
SQL - informe SELECT * FROM CIDADE.
Transaction - selecione trCliente.

Coloque agora um TDataSource da aba Data Access e mude Name para dsCidade e em DataSet selecione queCidade.
No evento AfterPost de queCidade digite o código:

queCidade.ApplyUpdates;
trCliente.CommitRetaining;

No evento AfterDelete selecione o mesmo método para não repetir código.
Pronto. Está feita a configuração de acesso, tanto para leitura quanto para escrita, em uma tabela do MySQL. Crie uma interface seguindo os passos descritos no post Lazarus - Acessando banco de dados com SQLdb - Parte I.
Selecione o form principal e, no editor de código, digite abaixo de Implementation:

uses u_dmdados;

Localize o evento OnShow na aba Eventos do Inspetor de objetos.  Dê um duplo clique à direita e digite:

dmDados.dbCliente.Open;

Assim, sempre que o programa for iniciado a conexão com o banco de dados será aberta.

Usando ZeosLib

Usaremos a versão 7.0 do ZeosLib disponível no grupo Lazarus-BR. Para instalar o pacote siga as instruções apresentadas no post Lazarus - Conectando PostgreSQL com ZeosLib. Coloque um TZConnection no Data Module. Defina as propriedades:

AutoCommit - deixe em True para que as transações no banco sejam comitadas automaticamente.
Database - informe o nome do banco de dados criado anteriormente.
HostName - informe o nome ou IP do servidor do banco. Para máquina local informe localhost.
Name - digite dbCliente.
Password - informe a senha do usuário. Em geral a senha do usuário root.

Protocol - informe mysql-5. Observe a versão do MySQL que você está usando.
User - informe o nome do usuário. Geralmente é root.

TransactionIsolation - define o nível de isolamento da transação. No nosso caso vamos usar tiReadCommitted.
Mude Connected para True. No Windows deve ocorrer um erro de ausência de dll. Faça o download aqui e copie-a para system32 do Windows. Depois de conectar com sucesso volte Connected para False.

Coloque um TZQuery e um TZUpdateSQL e configure-os como foi feito no artigo Lazarus - Conectando PostegreSQL com ZeosLib.
No TZUpdateSQL defina essas propriedades assim:

DeleteSQL - DELETE FROM CIDADE WHERE ID_CIDADE = :OLD_ID_CIDADE;
InsertSQL - INSERT INTO CIDADE VALUES (:ID_CIDADE, :NOME);
ModifySQL - UPDATE CIDADE SET NOME = :NOME WHERE ID_CIDADE = :OLD_ID_CIDADE;


Coloque um TDataSource da aba Data Access e defina Name como dsCidade e em DataSet selecione a TZQuery anterior. Ai está. Agora crie a interface com nos posts anteriores.

Atualizado em 04/06/2010.

Firebird - Vem ai a versao 2.5

 O banco de dados Firebird®, de código aberto, possui excelente performance e expressiva escalabilidade, indo desde modelos embarcados (mono-usuário) até sistemas empresariais com múltiplos bancos de mais de 500GB e centenas de conexões simultâneas.
O Firebird suporta o padrão ACID, triggers, stored procedures, UDF e eventos; roda nas versões 32 e 64 bits do Windows, Linux, MacOS X, HP-UX, FreeBSD, etc., sendo muito fácil a migração entre essas plataformas.
Um dos recursos chave do Firebird é a arquitetura multi-geracional, que permite o desenvolvimento e suporte de sistemas híbridos OLTP e OLAP. Suporta o padrão ACID, triggers, stored procedures, UDF e eventos; possui suporte compreensivo ao padrão SQL92, além de inúmeras opções de conectividade.
A combinação de alta performance, baixo consumo de recursos, escalabilidade suprema, instalação simples e silenciosa e distribuição 100% livre de royalties, fazem do Firebird uma escolha atrativa para todos os tipos de desenvolvedores e fornecedores de software. È utilizado por aproximadamente um milhão de desenvolvedores de software em todo o mundo.
Participe da campanha de divulgação acessando MindTheBird.

Java - Certificado de Programador Sun (SCJP)

Há pouco tempo escrevi um artigo na revista Urissanê - revista eletrônica do curso de Sistemas de Informação do CEULS/ULBRA, onde trabalho. Nesse artigo eu apresento diretrizes gerais sobre uma das certificações de TI mais procuradas - a SCJP. Abordamos cada certificação Java que a Sun oferece, mostrando as diferenças entre elas, como e onde se inscrever para o exame, como se preparar, dicas gerais sobre o conteúdo do exame, informações sobre o exame propriamente dito e o que acontece depois do exame. Leia o artigo 4 no site do curso. Logo estarei iniciando neste blog uma série de artigos com informações fundamentais para os candidatos a essa certificação, uma espécie de tutorial Java de preparação.