Tutorial de conexão Lazarus ao PostegreSQL

https://wiki.freepascal.org/Lazarus_Database_Tutorial/pt

Lazarus Database Tutorial/pt

│ Deutsch (de) │ English (en) │ español (es) │ français (fr) │ Bahasa Indonesia (id) │ italiano (it) │ 日本
語 (ja) │ Nederlands (nl) │ português (pt) │ русский (ru) │ 中文（中国大陆） (zh_CN) │ 中文（台灣） (zh_TW) │

Contents
 [hide] 

 1Introdução
 2Lazarus e MySQL
o 2.1Comece a trabalhar com MySQL no Linux ou Windows
o 2.2Comece a trabalhar com FPC no modo texto
o 2.3Conectando ao MySQL uma Aplicação Lazarus
 2.3.1Download do Código-Fonte do MYSQL
 3Lazarus e PostgreSQL
 4Lazarus and SQLite
o 4.1Introduction
o 4.2Requirementos
o 4.3How To Use (Basic Usage)
o 4.4Remarks
 5Lazarus and MSSQL
 6Lazarus e Interbase / Firebird
o 6.1FBLib Firebird Library
 7Lazarus and dBase
 8Related Links
 9Contributors and Changes
Introdução
Este tutorial mostra como usar o Lazarus com uma variedade de Bancos de dados.
O Lazarus suporta uma diversidade de banco de dados fora-da-caixa, entretanto os
desenvolvedores instalam os pacotes adequados para cada um. Você pode acessar o banco de
dados por código ou jogando componentes no formulário. Os componentes do tipo data-aware (que
precisam de uma fonte de dados para funcionar) representam campos e são conectados ajustando
a propriedade DataSource para apontar para o TDataSource. O Datasource representa a tabela e é
conectado ao componente do banco de dados (exemplos: TPSQLDatabase, TSQLiteDataSet)
ajustando a propriedade DataSet. Os componentes data-aware ficam localizados na aba "Data
Controls". Os controles Datasource e o Database estão localizados na aba "Data Access".

Lazarus e MySQL
Comece a trabalhar com MySQL no Linux ou Windows
Siga as instruções no Manual do usuário MySQL. Certifique-se que o mysqld daemon está rodando
satisfatoriamente, e que todos os potencias usuários(incluindo root, mysql,você mesmo e qualquer
outro que possa necessitá-lo) tenham os privilégios a eles necessários, para os possíveis hosts que
possam necessitá-lo(incluindo 'localhost', o hostname local, e outros hosts na sua rede) para manter
consistência e segurança. É preferivel que todos os usuários incluindo o root tenham passwords.
Teste as ações do sistema de banco de dados usando os exemplos dados no manual do mysql, e
certifique-se que todos os usuários sejam confiáveis no acesso.

Comece a trabalhar com FPC no modo texto

Este é o diretório com programa de exemplo $(fpcsrcdir)/packages/base/mysql/. Voce pode
encontrar código fonte do FPC (Free Pascal Compiler) no Lazarus: Menu Tools -> Options ->
Environment -> Paths tab -> FPC source directory. Possivelmente o endereço para o mysql seja
em /usr/share/fpcsrc/packages/base/mysql (RPM) ou c:\lazarus\fpcsrc\packages\base\mysql\ (no
windows). Este diretório contém também as units mysql.pp, mysql_com.pp e mysql_version.pp.
Antes de rodar o script de teste, voce necessita criar o banco de dados chamada testdb: faça isso
logando-se no prompt do mysql (o root com todos os privilegios) e dando o seguinte comando:

CREATE DATABASE testdb;

Certifique-se que todos os usuário tenham privilegios de acesso apropriados:

GRANT ALL ON testdb TO johnny-user IDENTIFIED BY 'johnnyspassword';

Existe um script chamado mkdb que você deve tentar executar:

sh ./mkdb

Este vai provavelmente falhar, já que o sistema não vai autorizar um usuário anônimo a acessar o
banco de dados. Então mude o script usando um editor de modo que a linha invocando o MySQL
seja:

mysql -u root -p ${1-testdb} << EOF >/dev/null

e tente executá-lo novamente entrando o seu password no prompt. Com sorte você deve ter
conseguido criar o banco de dados de teste: teste-o (enquanto logado no monitor do MySQL)
issuing o estamento do MySQL.

select * from FPdev;

Você deve ver uma tabela listando o ID, nome de usuário e e-mail de alguns dos desenvolvedore do
FPC.
Agora tente executar o program de teste testdb.pp (ele pode precisar ser compilado e vai quase
certamente falhar na primeira tentativa!!).
Eu obtive que o programa não poderia se conectar ao mysql por várias razões:

 Meu sistema (SuSE Linux v9.0) instal o mysql v4.0.15, não a versão 3 para a qual o pacote
foi desenhado.

 O programa precisa ter nomes de usuários e passwords para ter acesso ao banco de
dados.

 O compilador precisa saber onde encontrar as bibliotecas mysql (se você não instalou as
bibliotecas de desenvolvimento MySQL, faça-o agora).
Eu criei uma cópia de testdb.pp chamada trydb.pp em vez de editar o original - isso quer dizer que
os arquivos originais ainda são reparados em subseqüentes atualizações do CVS. Também copiei
os arquivos do subdiretório mysql/ver40/ para o subdiretório principal mysql/, renomeando-os para
mysql_v4.pp, mysql_com_v4.pp and mysql_version_v4.pp, certificando-me de nomear cada unidade
dentro de cada arquivo correspondente. Modifiquei o estamento uses em trydb.pp para uses
mysql_v4 e o estamento em mysql_v4 para

uses mysql_com_v4

Adicionei uma linha em /etc/fpc.cfg para apontar para minhas bibliotecas:

-Fl/lib;/usr/lib

O passo seguinte pode não ser necessário se as devel-libraries estiverem instaladas como os links
que serão criados para você, mas não custa verificar. Eu tive que achar o nome real da biblioteca
mysqlclint no diretório /usr/lib e no meu caso tive que entrar o comando:

ln -s libmysqlclient.so.12.0.0 lmysqlclient

para fazer um link simbólico permitindo o FPC achar a biblioteca. Eu também criei o link

ln -s libmysqlclient.so.12.0.0 mysqlclient

e pus links similares em vários outros subdiretórios. Alguns usuários podem precisar adicionar o
seguinte link:

ln -s libmysqlclient.so.12.0.0 libmysqlclient.so

Eu modifiquei o trydb.pp para incluir detalhes de usuários, inicialmente adicionando host, usuário e
password como constantes:

const
host : Pchar= 'localhost';
user : Pchar= 'myusername';
passwd: Pchar = 'mypassword';

Também achei que não poderia conectar ao mysql usando a chamada mysql_connect(), mas tive
que usar mysql_real_connect() que tem muitos mais parâmetros. Para complicar, o número de
parâmetros parece ter mudado entre a versão 3 (quando eram sete) e a versão 4 (em que há oito).
Antes de usar mysql_real_connect eu tive que usar mysql_init() que não é encontrada no mysql.pp
original mas o é no mysql_v4.pp.
Assim o código para a conexão ao banco de dados agora é:

{ umas poucas variáveis extra }

var
alloc : PMYSQL;

{fragmento do programa principal }

begin
if paramcount=1 then
begin
Dummy:=Paramstr(1)+#0;
DataBase:=@Dummy[1];
end;

Writeln ('Allocating Space...');

alloc := mysql_init(PMYSQL(@qmysql));
Write ('Connecting to MySQL...');
 sock := mysql_real_connect(alloc, host, user, passwd, database, 0,
nil, 0);
if sock=Nil then
begin
Writeln (stderr,'Couldnt connect to MySQL.');
Writeln (stderr, 'Error was: ', mysql_error(@qmysql));
halt(1);
end;
Writeln ('Done.');
Writeln ('Connection data:');
{$ifdef Unix}
writeln ('Mysql_port  : ',mysql_port);
writeln ('Mysql_unix_port : ',mysql_unix_port);
{$endif}
writeln ('Host info  : ',mysql_get_host_info(sock));
writeln ('Server info  : ',mysql_stat(sock));
writeln ('Client info  : ',mysql_get_client_info);

Writeln ('Selecting Database ',DataBase,'...');

if mysql_select_db(sock,DataBase) < 0 then
begin
Writeln (stderr,'Couldnt select database ',Database);
Writeln (stderr,mysql_error(sock));
halt (1);
end;
{... as original contents of testdb.pp}

Agora - pronto para começar a compilar trydb.pp?

fpc trydb

successo! Agora execute:

./trydb

Oba! Consegui a lista dos desenvolvedores do FPC!

Uns poucos refinamentos mais: faça a entrada de detalhes dos usuários e os comandos do mysql
interativos, usando variáveis em vez de constantes, e permita que vários comandos SQL sejam
inseridos, até que o comando quit seja encontrado: veja full program listing, onde os detalhes de
usuário são inseridos do console e o programa vai para um loop onde os comandos SQL são
inseridos do console (sem ponto e vírgula no final) e as respostas são impressas na tela, até que
'quit' é inserido pelo teclado.
Veja Sample Console Listing.

Conectando ao MySQL uma Aplicação Lazarus

Este tutorial mostra como conectar o Lazarus ao banco de dados MySQL e executar queries simples
usando somente os componentes básicos do Lazarus; ele não usa componentes Data Aware, mas
ilustra os princípios de interface com banco de dados.
Crie um novo projeto no Lazarus:
Projeto -> Novo Projeto -> Application

Um novo formulário gerado automaticamente vai aparecer.

Aumente a área do formulário até preencher aproximadamente a metade da tela e renomeie o
formulário e o seu caption para 'TryMySQL'.
Da aba Standard Component ponha três Edit Boxes do lado superior esquerdo do formulário e
imediatamente acima de cada Box ponha um Label. Mude os nomes e captions para 'Host' (e
HostLLabel, HostEdit), 'UserName' (e UserLabel, UserEdit) e 'Password' (com PasswdLabel e
PasswdEdit). Alternativamente você pode usar componentes LabelledEdit da aba Additional.
Selecione a caixa Passwd Edit e encontre a propriedade PasswordChar : mude-a para "*" ou algum
outro caractere de modo que quando você escreva uma senha os caracteres não apareçam na tela
mas sejam representados por uma série de caracteres "*". Certifique-se de que a propriedade Text
para cada Edit Box esteja em branco.
Agora ponha outra Edit Box e o Label correspondente no topo direito do formulário. Mude o Label
para 'Enter SQL Command' e o seu nome para CommandEdit.
Coloque três Buttons no formulário: dois do lado esquerdo sob as Edit Boxes e um do lado direito
sob a Command Box.
Rotule os botões do lado esquerdo como 'Connect to Database' (ConnectButton) e 'Exit' (ExitButton)
e o que está do lado direito como 'Send Query' (QueryButton).
Ponha um Memo grande rotulado e nomeado como 'Results' (ResultMemo) abaixo do lado direito,
preenchendo a maior parte do espaço disponível. Encontre a propriedade ScrollBars do Memo e
selecione ssAutoBoth , de modo que as Scroll Bars apareçam automaticamente se o texto
preencheer o espaço. Configure a propriedade WordWrap como True.
Ponha uma Status Bar (da aba Common Controls) embaixo no formulário e faça a propriedade
SimpleText igual a 'TryMySQL'.
Um screenshot do formulário pode ser visto aqui: Mysql Example Screenshot
Agora você precisa escrever alguns event handlers.
As três caixas de edição à esquerda são para a inserção do hostname, do username e da password.
Quando elas são inseridas satisfatoriamente, o botão de conexão é clicado. O eventhandler OnClick
para este botão é baseado em parte do seguinte programa FPC em modo texto.
As respostas do banco de dados não podem agora ser escritas usando os estamentos Pascal write
e writeln: em vez disso, as respostas têm que ser convertidas em strings e mostradas no Memo.
Mesmo que os estamentos Pascal write e writeln sejam capazes de realizar muitas conversões
rápidas de tipo, o uso do Memo para saída de texto necessita da conversão explícita de tipo de
dados para a forma correta de string, portanto variáveis PChar têm que ser convertidas para strings
usando StrPas e inteiros precisam ser convertidos com IntToStr.
Strings são mostradas no Memo fazendo

procedure ShowString (S : string);

(* display a string in a Memo box *)
begin
trymysqlForm1.ResultsMemo.Lines.Add (S)
end;

The ConnectButton event handler thus becomes:

procedure TtrymysqlForm1.ConnectButtonClick(Sender: TObject);

(* Connect to MySQL using user data from Text entry boxes on Main Form
*)
var strg: string;

begin

dummy1 := trymysqlForm1.HostEdit.text+#0;
host := @dummy1[1];
dummy2 := trymysqlForm1.UserEdit.text+#0;
user := @dummy2[1] ;
dummy3 := trymysqlForm1.PasswdEdit.text+#0;
passwd := @dummy3[1] ;
alloc := mysql_init(PMYSQL(@qmysql));
sock := mysql_real_connect(alloc, host, user, passwd, database, 0,
nil, 0);
if sock=Nil then
begin
strg :='Couldnt connect to MySQL.'; showstring (strg);
Strg :='Error was: '+ StrPas(mysql_error(@qmysql)); showstring
(strg);
end
else
begin
trymysqlForm1.statusBar1.simpletext := 'Connected to MySQL';
strg := 'Now choosing database : ' + database; showstring (strg);
{$ifdef Unix}
strg :='Mysql_port  : '+ IntToStr(mysql_port); showstring
(strg);
strg :='Mysql_unix_port : ' + StrPas(mysql_unix_port); showstring
(strg);
{$endif}
Strg :='Host info  : ' + StrPas(mysql_get_host_info(sock));
showstring (strg);
Strg :='Server info  : ' + StrPas(mysql_stat(sock));
showstring (strg);
Strg :='Client info  : ' + Strpas(mysql_get_client_info);
showstring (strg);

trymysqlForm1.statusbar1.simpletext := 'Selecting Database ' +

DataBase +'...';
if mysql_select_db(sock,DataBase) < 0 then
begin
strg :='Couldnt select database '+ Database; ShowString (strg);
Strg := mysql_error(sock); ShowString (strg);
end
end;
end;

A caixa de texto à direita permite inserção de um estamento SQL, sem um ponto e vírgula no final.
Quando você estiver satisfeito com o seu conteúdo ou sintaxe, o botão SendQuery é pressionado e
a query é processada, com os resultados sendo escritos no ResultsMemo.
O event handler SendQuery é baseado na versão modo texto do FPC, exceto que conversões
explícitas de tipo têm que ser feitas antes de a string ser mostrada.
Uma diferença do modo texto do programa FPC é que se uma condição de erro for detectada, o
programa não pára e a MySQL não é fechada. Em vez disso, o controle retorna ao formulário
principal e é dada uma oportunidade de corrigir a inserção antes que o comando seja enviado. A
aplicação finalmente fecha (com o fechamento da MySQL) quanto o botão Exit é clicado.
O código para SendQuery é o seguinte:

procedure TtrymysqlForm1.QueryButtonClick(Sender: TObject);

var
dumquery, strg: string;
begin
dumquery := TrymysqlForm1.CommandEdit.text;
dumquery := dumquery+#0;
query := @dumquery[1];
trymysqlForm1.statusbar1.simpletext := 'Executing query : '+
dumQuery +'...';
strg := 'Executing query : ' + dumQuery; showstring (strg);
if (mysql_query(sock,Query) < 0) then
begin
Strg :='Query failed '+ StrPas(mysql_error(sock)); showstring
(strg);
end
else
begin
recbuf := mysql_store_result(sock);
if RecBuf=Nil then
begin
Strg :='Query returned nil result.'; showstring (strg);
end
else
begin
strg :='Number of records returned  : ' +
IntToStr(mysql_num_rows (recbuf));
Showstring (strg);
Strg :='Number of fields per record : ' +
IntToStr(mysql_num_fields(recbuf));
showstring (strg);
rowbuf := mysql_fetch_row(recbuf);
while (rowbuf <>nil) do
begin
Strg :='(Id: '+ rowbuf[0]+', Name: ' + rowbuf[1]+ ',
Email : ' +
rowbuf[2] +')';
showstring (strg);
rowbuf := mysql_fetch_row(recbuf);
end;
end;
end;
end;

Salve seu projeto, pressione Run -> Run

Download do Código-Fonte do MYSQL
Uma listagem completa do programa está disponível aqui Sample Source Code
Lazarus e PostgreSQL
Este é um pequeno tutorial usando Lazarus 0.9.12 ou posterior para se conectar a um banco de
dados PostgreSQL, local ou remoto, usando o componente TPQConnection.
Após a instalação correta, siga estes passos:

 Coloque um PQConnection da aba SQLdb

 Coloque um SQLQuery da aba SQLdb
 Coloque um SQLTransaction da aba SQLdb
 Coloque um DataSource da aba DataAccess
 Coloque um DBGrid da aba DataControls

 No PQConnection preencher:
 "transaction property" com o respectivo objeto SQLTransaction
 Database name
 HostName
 UserName + password

 Verifique se o SQLTransaction foi automaticamente alterado para apontar para o

PQConnection

 No SQLQuery preencher:
 "transaction property" com o respectivo objeto
 "database property" com o respectivo objeto
 SQL (algo como 'select * from nometabela')

 No objeto DataSource preencher a propriedade DataSet com o objeto SQLQuery

 No DBGrid preencher o datasource como o DataSource Object

Mude tudo para connected (conectado) e active (ativo) e o DBGrid deverá ser preenchido em tempo
de desenho. TDBText e TDBEdit parece funcionar mas (para mim) eles apenas mostram dados
( _show_ _data_).
Para alterar conteúdos no banco de dados, chamei o DB Engine direto com o seguinte código:

try
sql:= 'UPDATE table SET setting=1';
PQDataBase.Connected:=True;
PQDataBase.ExecuteDirect('Begin Work;');
PQDataBase.ExecuteDirect(sql);
PQDataBase.ExecuteDirect('Commit Work;');
PQDataBase.Connected:=False;
except
on E : EDatabaseError do
MemoLog.Append('DB
ERROR:'+sql+chr(13)+chr(10)+E.ClassName+chr(13)+chr(10)+E.Message);
on E : Exception do

MemoLog.Append('ERROR:'+sql+chr(13)+chr(10)+E.ClassName+chr(13)+chr(10
)+E.Message);
end;

 Notas:
  Testado no windows, Lazarus 0.9.12 + PgSQL 8.3.1
 Alguns testes em linux, Lazarus 0.9.12 and PgSQL 8.0.x

 Instalação e erros:
 Na versão testada do Lazarus .12, campos do tipo "text" e "numeric" tem bugs
 Usei sem problemas "char fixed size", "int" e "float8"
 Às vezes reiniciar o Lazarus resolve erros estúpidos...
 Depois de alguns erros, as transações permanecem ativas e devem ser
desativadas manualmente
 As alterações feitas no Lazarus são, naturalmente, não visível até a transação ser
confirmada
 The integrated debugger seems buggy (at least in windows) - sometimes running
outside of the IDE may help to find errors
 (O depurador integrado parece infestado (pelo menos no windows) - às vezes
executando fora da IDE pode ajudar a encontrar erros)
 No linux determinadas mensagens de erro são impressas na console -- executar
seu programa na linha de comando, às vezes há algumas informações úteis de depuração,
extra
 Erro: "Can not load Postgresql client. Is it installed (libpq.so) ?"
 Adicione o caminho para pesquisa libpq* da instalação PostgreSQL.
 No linux adicione o caminho para o arquivo libpq.so para a seção
"libraries" em seu /etc/fpc.cfg file. Por exemplo: -Fl/usr/local/pgsql/lib
 No windows, adicione essas "libs" em qualquer lugar na variável de
ambiente Path ou diretório de project
 Em windows, copiei todas as DLLs do diretório C:\Program
Files\PostgreSQL\8.1\bin para outro diretório no PATH
 Ou adicionar este diretório postgres \bin para o caminho
Lazarus and SQLite
by Luiz Américo Translated by Edson Leonel de oliveira

Introduction
TSqliteDataset e TSqlite3Dataset são comandos TDataset que acessam, respectivamente, bases de
dados sqlite versões 2.8.x e 3.2.x. Abaixo está uma lista das principais vantagens e desvantagens:
Vantagens:

 Flexível: programadores podem escolher usar ou não a linguagem SQL, acessando tabelas
com layouts simples ou qualquer layout complexo disponível no SQL/sqlite
 Atualização automática da base de dados: não precisa comandar manualmente a
atualização com comandos SQL, um método simples a executa
 Rápido: faz um cache dos dados na memória, navegando rapidamente nos dados
 Sem configuração e instalação de servidor: conecta-se usando a biblioteca dinâmica sqlite
Disvantagens

 Requer arquivo externo (biblioteca sqlite)

Requirementos

 Para bases de dados sqlite2:

 fpc 2.0.0
 Lazarus 0.9.10
 biblioteca runtime sqlite 2.8.15 ou acima (pegar em www.sqlite.org)

 Para bases de dados sqlite3:

 fpc 2.0.2
 Lazarus 0.9.11 (svn revisão 8443 ou acima)
 biblioteca runtime sqlite 3.2.1 ou acima (pegar em www.sqlite.org)
Antes de inicalizar um projeto lazarus, tenha certeza que:

 a biblioteca sqlite esteja no PATH do sistema ou em um diretório executável

 sob o Linux, colocar cmem como a primeira unidade nas cláusulas em uso na rotina
principal (main)
How To Use (Basic Usage)
Install the package found at /components/sqlite directory (see instructions here)
At design time set the following properties:

 FileName: path of the sqlite file [required]

 TableName: name of the table used in the sql statement [required]
 Sql: a SQL select statement [optional]
Creating a Table (Dataset)
Double click in the component icon or use the 'Create Table' item of the popup menu that appears
when clicking the right mouse button. A simple self-explaining table editor will be show.

Here is all field types supported by TSqliteDataset and

TSqlite3Dataset:

Integer
AutoInc
String
Memo
Bool
Float
Word
DateTime
Date
Time
LargeInt
Currency

Retrieving the data

After creating the table or with a previously created Table, open the dataset with Open method. If the
SQL property was not set then all records from all fields will be retrieved, the same if you set the SQL
to:

SQL:='Select * from TABLENAME';

Applying changes to the underlying datafile

To use the ApplyUpdates function, the dataset must contain at least one field that fills the
requirements for a Primary Key (values must be UNIQUE and not NULL)
It's possible to do that in two ways:

 Set PrimaryKey property to the name of a Primary Key field

 Add an AutoInc field (This is easier since the TSqliteDataSet automatically handles it as a
Primary Key)
If one of the two conditions is set then just call
 ApplyUpdates;

PS1: If both conditions are set, the field corresponding to PrimaryKey is used to apply the updates.
PS2: Setting PrimaryKey to a field that is not a Primary Key will lead to loss of data if ApplyUpdates
is called, so ensure that the chosen field contains not Null and Unique values before using it.

Remarks

 Although it has been tested with 10000 records and worked fine, TSqliteDataset keeps all
the data in memory, so remenber to retrieve only the necessary data (principally with Memo
Fields).
 The same datafile (Filename property) can host several tables/datasets
 Several datasets (different combinations of fields) can be created using the same table
simultaneously
 It's possible to filter the data using WHERE statements in the sql, closing and reopening the
dataset (or calling RefetchData method). But in this case, the order and number of fields must
remain the same
 It's also possible to use complex SQL statements using aliases, joins, views in multiple
tables (remember that they must reside in the same datafile), but in this case ApplyUpdates
won't work. If someone wants to use complex queries and to apply the updates to the datafile,
mail me and I will give some hints how to do that
 Setting filename to a sqlite2.x datafile not created by TSqliteDataset and opening it is
allowed but some fields won't have the correct field type detected. These will be treated as string
fields.
Generic examples can be found at fpc/fcl/db/sqlite CVS directory
Luiz Américo pascalive(at)bol(dot)com(dot)br

Lazarus and MSSQL

It is working with Zeoslib (latest cvs), see the links on bottom of page.

Lazarus e Interbase / Firebird

Olhe Install Packages. On this page is a first small example en explanation about how to connect to
an IB or FB server. Aqui o início de tradução (e atualização):
No diretório onde o Lazarus é instalado você vai encontrar subdiretórios, e o primeiro
(alfabeticamente) chama-se components. Este, por sua vez, tem subdiretórios
como sqlite e sqldb. O primeiro contém componentes de conexão com o BD e descendentes de
Tdataset para o respectivo banco, enquanto o sqldb é mais genérico pois consiste de TSQLQuery
(um TDataset) e TSQLTransaction usados para todos os tipos de BD e uma T??Conection para
realizar a conexão. Nesse artigo vamos instalar o pacote sqldb juntamente com a conexão
para Interbase. Antes, porém, de iniciar a instalação do pacote seria bom discutir o porque de
Lazarus não instalar componentes de conexão com o BD. Esses componentes precisam das
bibliotecas clientes para funcionar no PC onde são usados. Como o Lazarus atualmente não suporta
ligações dinâmicas, todas as bibliotecas precisam ser compiladas para a IDE. Como não se espera
que os desenvolvedores tenham todos os BD instalados, não é possível ter como padrão instalar os
componentes de conexão. Delphi também só instala os componentes de BD que são prontamente
encontrados no computador (componentes ADO) e componentes que não necessitam bibliotecas
(BDE: Paradox, DBase). Para instalar o pacote vá em Pacotes → Abrir arquivo de pacote. No
diálogo seguinte navegue para /usr/bin/lazarus/components/sqldb ou ao diretório correspondente em
OS X ou Windows e escolha o arquivo sqldblaz.lpk. Se tudo correr como planejado você verá o
Gerenciador de Pacotes, que exibe uma árvore com os arquivos do pacote e os pacotes requeridos.
Então pressione Compilar se você não quer instalar o componente na IDE, caso contrário clique
em Instalar. Nesse caso aparecerá uma advertência explicando que o Lazarus suporta apenas
ligações a bibliotecas estáticas e pergunta se quer reconstruir Lazarus. Pressione Sim e o programa
será reconstruido. Se tudo correu bem você verá uma nova palheta chamada SQLdb e seu último
componente da direita é justamente o de conexão com bancos Firebird ou InterBase.
Para instalar o Firebird e criar/gerenciar banco de dados, olhe esse artigo de José
Ribeiro: http://www.vivaolinux.com.br/artigo/Criando-um-banco-de-dados-no-Flamerobin-(Firebird)/

Also work with the latest Zeoslib (from cvs).

FBLib Firebird Library

FBLib é uma biblioteca open source para acesso direto (sem Data Aware) ao Firebird.
Características atuais incluem:

 Acesso direto ao Firebird 1.0.x 1.5.x Classic ou SuperServer

 Multiplataforma (Win32, Gnu/Linux, FreeBSD)
 Seleção automática da biblioteca cliente 'fbclient' ou 'gds32'
 Query com parâmetros
 Suporta dialetos SQL 1 e 3
 Licença LGPL
 Extração de Metadata
 Parser Simples de Scripts
 Apenas 100-150 KB adicionados ao executável
 Suporta campos BLOB
 Exporta dados para HTML SQL Script
 Gerenciador de Serviço (backup, restore, gfix...)
 Alerta de Eventos
Você pode acessar a documentação em FBLib's website.
Aqui você encontra uma versão atualizada. Ou, diretamente pelo SVN: [1]

Lazarus and dBase

Tony Maro
You might also want to visit the beginnings of the TDbf Tutorial page
FPC includes a simple database component that is similar in function to the Delphi TTable
component called "TDbf" (TDbf Website) that supports a very basic subset of features for dBase
files. It is not installed by default, so you will first need to install the Lazarus package from the
"lazarus/components/tdbf" directory and rebuild your Lazarus IDE. It will then appear next to the
TDatasource in your component palette.
The TDbf component has an advantage over other database components in that it doesn't require
any sort of runtime database engine, however it's not the best option for large database applications.
It's very easy to use. Simply, put, drop a TDbf on your form, set the runtime path to the directory that
your database files will be in, set the table name, and link it to your TDatasource component.
Real functionality requires a bit more effort, however. If a table doesn't already exist, you'll need to
create it programmatically, unless there's a compatible table designer I'm not familiar with.
Attempting to open a non-existant table will generate an error. Tables can be created
programmatically through the component after the runtime path and table name are set.
For instance, to create a table called "dvds" to store your dvd collection you would drop it on your
form, set the runtime path, and set the table name to "dvds". The resulting file will be called
"dvds.dbf".
In your code, insert the following:

Dbf1.FilePathFull := '/path/to/my/database';
Dbf1.TableName := 'dvds';
With Dbf1.FieldDefs do begin
Add('Name', ftString, 80, True);
Add('Description', ftMemo, 0, False);
 Add('Rating', ftString, 5, False);
end;
Dbf1.CreateTable;

When this code is run, your DVD collection table will be created. After that, all data aware
components linked through the TDatasource to this component will allow easy access to the data.
Adding indexes is a little different from your typical TTable. It must be done after the database is
open. It's also the same method you use to rebuild the indexes. For instance:

Dbf1.Exclusive := True;
Dbf1.Open;
Dbf1.AddIndex('dvdsname','Name',[ixPrimary, ixUnique,
ixCaseInsensitive]);
Dbf1.AddIndex('rating.ndx', 'Rating', [ixCaseInsensitive]);
Dbf1.Close;

The first (primary) index will be a file called "dvdsname.mdx" and the second will be a file named
"rating.ndx" so in a multiple table database you must be careful not to use the same file name again.
I will try to add a more detailed example at a later date, but hopefully this will get those old Delphi
programmers up and running with databases in Lazarus!

Related Links
 Creating Databases Applications with Lazarus using the DB-unit
 Creating a database application using MySQL
 Creating a database application using the Zeos components
 Pascal Data Objects is a database API that worked for both FPC and Delphi and utilises
native MySQL libraries for version 4.1 and 5.0. It's inspired by PHP's PDO class.
https://trac.synsport.com:8000/index.php/pdo/wiki (username/password is guest/guest)

Contributors and Changes