Páginas

quinta-feira, 27 de maio de 2010

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.

quinta-feira, 20 de maio de 2010

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.

sábado, 15 de maio de 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.

quinta-feira, 6 de maio de 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.

segunda-feira, 3 de maio de 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.
 
Creative Commons License
This work by Carlos Alberto P. Araújo is licensed under a Creative Commons Atribuição-Uso não-comercial-Compartilhamento pela mesma licença 3.0 Brasil License.