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) │

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

This page has been converted from the epikwiki version.

Lazarus e PostgreSQL, traduzido por User: jrxds (15/01/2012).