Banco de Dados - Firebird
Utilizando SGBD FireBird 2.0 com ADO.NET
Neste artigo poderemos ver de forma básica, como fazer para se comunicar e trocar informações com o banco de dados, além de conhecer um pouco da parte teórica, que é muito importante para o desenvolvimento correto de uma aplicação.
por Wilker Silva de OliveiraDe forma básica, irei falar um pouco do ADO.NET antes de exemplificar a
utilização com o FireBird 2.0.
ADO.NET é uma “reconstrução”, do antigo
ADO, sendo completamente integrado com o .NET Framework, disponibilizando um
grande número de classes e possibilitando em uma comunicação bem mais fácil com
os SGBD’s.
Ou seja, ele nada mais é que um conjunto de classes definidas pelo
.NET Framework, que auxilia na comunicação com os SGBD’s.
Vantagens de Usar o ADO.NET
Algumas das vantagens em utilizar o ADO.NET é que você contará com uma alta
escalabilidade, desempenho, segurança, performance em seu sistema e maior
produtividade.
Agora com o ADO.NET, ao utilizar um DataSet, o mesmo, por
padrão, trabalha desconectado. Os dados ficam armazenados em um cachê local,
assim a conexão pode ser fechada e o cliente pode trabalhar desconectado, e caso
seja necessário uma atualização dos dados, basta efetuar uma nova conexão.
Arquitetura
fig. 1: Arquitetura
.Net
Os componentes que formam a arquitetura do ADO.NET são:
Data Source, Data Provider e o DataSet.
• Data Source: representa um banco
de dados físico ou um arquivo XML;
• Data Provider: se encarrega de criar as
conexões e processar comandos;
• DataSet: representa um ou mais data source
na memória.
Componentes do ADO.NET
fig. 2: Arquitetura
.Net
As classes do ADO.NET estão divididas em dois grupos:
Managed Providers e DataClasses.
• Managed providers: objetos que não
armazenam dados e são usados para ler e escrever em banco de dados: Connection,
DataAdapter, Command e DataReader. Para cada SGBD, existe uma classe para fazer
a comunicação com o banco de dados.
• DataClasses: são os objetos que podem
armazenar e manipular dados: DataSets, DataTables, DataRows, DataColumns,
DataRelations, Constraints e DataView.
Detalhando um pouco os objetos do
grupo Managed Providers e DataClasses, temos:
Managed providers:
• Connection: é através dessa classe, que será feita a
comunicação com o banco de dados. Ela recebe uma string de conexão, onde serão
informados os dados para acesso ao banco.
• Command: recebe uma
string com o comando SQL;
• DataAdapter: um repositório para o
Command. Dependendo da string passada para o Command, ele será preenchido com os
dados resultantes do processamento. Através dos comandos informados, ele
realizará junto ao banco de dados, algumas tarefas, como: pesquisar
(SelectCommand), inserir (InsertCommand), alterar (UpdateCommand) ou excluir
(DeleteCommand). Dependendo do comando, será usado para executar o DataAdapter
um desses objetos: ExecuteNonQuery() - usado para INSERT, UPDATE e DELETE,
retorna o número de registros afetados; ExcuteEscalar() – usado em consultas,
quando deseja-se retornar apenas uma linha e uma coluna, ex.: verificar o saldo
total da conta, código do cliente com o cpf XXX, mesmo que a consulta retorne
mais de uma linha, ele irá pegar apenas a primeira linha e a primeira coluna;
ExecuteReader() – utilizado quando a consulta irá retornar mais de um valor,
após a execução, ele preenche o DataReader com os resultados.
•
DataReader: utilizado para fazer leituras dos registros no banco de
dados. Após a execução de uma consulta, o DataReader será preenchido com os
resultados das consultas, para posterior leitura e preenchimentos de alguns
objetos, como por exemplo um TextBox.
Para cada SGBD, existe um provider
específico, porém, mudando apenas o seu prefixo. Ex: para SGBD Sql Server,
possui o prefixo SqlXXX (SqlConnection), para SGBD Oracle, possui o prefixo
OracleXXX (OracleCommand), para SGBD FireBird, possui um prefixo FbXXX
(FbDataAdapter).
Para poder usar um SGBD através do ADO.NET e com acesso
direto ao banco, é necessário verificar se existe um provider para o banco que
será utilizado, caso exista, será necessária à instalação do mesmo.
DataClasses:
• DataSet: objeto que armazena os
dados, uma copia exata ou parcial do banco de dados, possibilitando o trabalho
com o banco desconectado. Funciona como um banco de dados em memória, possuindo
coleções de tabelas (DataTables), campos (DataColumns), registros (DataRows),
constraints (Constraints) e relacionamentos (DataRelations). Os dados que
armazenam são manipulados em XML por padrão. Podendo ser passado entre camadas
sem nenhum problema.
• DataTable: esse objeto representa uma
tabela de dados na memória, usado por diversos outros objetos, como o DataSet.
Possui alguns métodos que auxiliam na criação de DataTables: DataColumn, DataRow
dentre outros. Esse objeto pode tanto ser criado independente como usados por
outros objetos.
Existem outros componentes do DataClasses que não serão
vistos aqui.
Exemplo de utilização do ADO.NET com Visual Studio 2005
Compreendido o básico do ADO.NET, irei demonstrar como é fácil a utilização
do ADO.NET com qualquer banco de dados.
Nesse exemplo, será mostrada a
utilização com o SGBD FireBird 2.0.
Lembrando, para que o mesmo possa
ser utilizado, é necessária a instalação do provider referente a esse SGBD, que
pode ser encontado no link:
http://www.firebirdsql.org/index.php?op=files&id=netprovider
Para baixar o SGBD FireBird 2.0, utilize o link:
http://prdownloads.sourceforge.net/firebird/Firebird-2.0.0.12748-0-Win32.exe?Download
A instalação do SGB FireBird 2.0 é muito simples, basta ir clicando
em avançar, seguindo as informações.
Feita a instalação do SGBD FireBird,
instale o provider, seguindo as informações passadas pelo assistente de
instalação.
Exemplificaremos através da tabela abaixo, a utilização dos
principais comandos para trabalhar com banco de dados no ADO.NET, através de uma
aplicação simples - cadastro de cliente - utilizando os comandos SQL INSERT,
UPDATE, DELETE E SELECT.
fig. 3: Tabela
Após ter
criado a tabela no banco de dados, conforme figura 3, podemos iniciar o
processo de construção de nossa aplicação.
Nesse Artigo, utilizaremos o
Visual Studio 2005.
Primeiramente iremos criar uma classe para a conexão com
o banco de dados:
Dica: Para poder usar essa conexão em qualquer
projeto futuro, aconselha-se criar uma DLL (Class Library).
No Visual
Studio 2005, clique em File > New > Project. Será aberta a janela de New
Project, clique em Visual C# > Windows. Na parte de Templates clique em Class
Library e escolha o nome do seu projeto. No nosso caso, o nome escolhido foi
Conexao_FireBird.
Para que possamos ter acesso ao provider do FireBird,
temos que criar um referência ao mesmo. No Solution Explorer, clique com o botão
direito do mouse em cima do nome do projeto, Conexao_FireBird, e escolha
Add Reference, aparecerá a janela conforme Figura 4:
fig. 4: Add
Reference
Na aba .Net, procure por FireBirdClient –
ADO.NET 2.0 Data Provider, e clique no botão OK.
Agora basta
escrever seu código conforme o exemplo abaixo:
using System;
using System.Collections.Generic;
using System.Text;
using FirebirdSql.Data.FirebirdClient;//provider do SGBD FireBird
// Conexao_FireBird
// Classe: classe_ConexaoFB
namespace classe_conexao
{
public class classe_ConexaoFB
{
private string strConexao;//STRING PARA CONEXÃO
private FbConnection conexao;//OBJETO CONEXÃO
/// <SUMMARY>
/// Construtor Padrão
/// </SUMMARY>
public classe_ConexaoFB() { }
/// <SUMMARY>
/// Construtor
/// Recebe como parametro os dados para conexão
/// </SUMMARY>
public classe_ConexaoFB(string strConexao)
{
//seta a string de conexão
set_strConexao(strConexao);
// configura a conexão
faz_Conexao();
}
/// <SUMMARY>
/// Configura a Conexão
/// Passa para o construtor da classe FbConnection
/// os dados para conexão
/// </SUMMARY>
private void faz_Conexao()
{
this.conexao = new FbConnection(get_strConexao());
}
/// <SUMMARY>
/// Abre a conexão com o banco de dados
/// </SUMMARY>
public void abre_Conexao()
{
this.conexao.Open();
}
/// <SUMMARY>
/// Fecha a conexão com o banco de dados
/// </SUMMARY>
public void fecha_Conexao()
{
this.conexao.Close();
}
/// <SUMMARY>
/// Retorna uma conexao com o banco de dados
/// </SUMMARY>
/// <RETURNS>Conexão com o banco de dados</RETURNS>
public FbConnection get_Conexao()
{
return this.conexao;
}
/// <SUMMARY>
/// Seta os dados da conexão recebidos
/// pelo construtor
/// </SUMMARY>
public void set_strConexao(string strConexao)
{
this.strConexao = strConexao;
}
/// <SUMMARY>
/// Retorna a string com os dados
/// para conexao
/// </SUMMARY>
/// <RETURNS>String com os dados</RETURNS>
public string get_strConexao()
{
return this.strConexao;
}
}
}
Salve as alterações e clique em Build > Build Solution.
Feito isso,
voçê poderá notar que dentro da pasta Bin/Debug, localizada dentro da
pasta de seu projeto, foi criado nossa dll para conexão com o banco FireBird.
Para poder utilizar essa dll com os programas criados, basta adicionar a
mesma ao projeto.
Vamos então criar um novo projeto para podermos testar
essa conexão e os comandos SQL.
No Visual Studio 2005, clique em File
> New > Project. Será aberta a janela de New Project, clique em Visual C#
> Windows. Na parte de Templates clique em Windows Application e escolha o
nome do seu projeto. No nosso caso, o nome escolhido foi Comunicacao_Banco.
Crie novamente a referência do provider FireBird para esse novo projeto,
conforme orientações acima
Crie um formulário conforme a imagem da
Figura 5:
fig. 5: Layout
Teste a
aplicação clicando em Debug > Start Debugging ou apertando a tecla F5.
Após ter testado nosso novo projeto, temos que adicionar a DLL criada ao
nosso projeto.
No Solution Explorer, clique com o botão direito do mouse no
nome do nosso projeto, Comunicacao_Banco, na aba Browse, conforme
Figura 6.
fig. 6: Add
Reference
Clique em Examinar, e procure pela
classe_conexao.dll, na pasta do nosso projeto criado anteriormente.
Clique no botão OK para incluir a DLL ao nosso projeto.
Pronto,
agora podemos trabalhar com o acesso a dados através do ADO.NET e com o SGBD
FireBird 2.0.
Após a criação do formulário conforme a Figura 1, vá até o
código fonte do seu projeto e coloque os seguintes namespaces: using classe_conexao;
using FirebirdSql.Data.FirebirdClient;
para poder trabalhar com a DLL que nos criamos e o provider do FireBird.
Para esse projeto, criei algumas variáveis conforme abaixo: //caminho para o banco de dados
private string caminho;
//string com os dados para conexão
private string strConexao;
//objeto do tipo classe_ConexaoFB
private classe_ConexaoFB conexao_FB;
//objeto FbDataAdapter para poder trabalhar com SQL
private FbDataAdapter adapt;
//objto FbDataReader para poder trabalhar com as consultas
private FbDataReader reader;
Criei também um método inicialize() para poder inicializar minhas
variáveis.
/// <SUMMARY>
/// Inicializa os dados
/// </SUMMARY>
private void inicialize()
{
this.caminho = @"D:\Apostial ADO.NET\Codigo Fonte\Banco\" +
"BANCOFB.FDB";
this.strConexao = "User=SYSDBA;" +
"Password=masterkey;" +
"DataBase=" + caminho + ";Dialect=3";
this.reader = null;
this.adapt = new FbDataAdapter();
this.conexao_FB = new classe_ConexaoFB();
}
Uma observação para as varíáveis this.caminho e this.strConexao, pois são
elas as responsáveis para a conexão com o banco de dados, onde: this.caminho
esta recebendo a string com o caminho para o banco de dados e this.strConexao
recebe os dados necessário para fazer a conexão com o banco, como usuário e
senha, qual o banco de dados, que no caso esta em this.caminho e o dialeto do
banco.
Mude as informações do caminho e usuário e senha conforme necessário.
No botão Cadastrar, de dois clique em cima dele, e informe o código
conforme abaixo: /// <SUMMARY>
/// Cadastra o cliente no banco de dados
/// </SUMMARY>
private void bt_cadastrar_Click(object sender, EventArgs e)
{
//cria uma string com o comando SQL para inserir os dados
string sql_Insert = "insert into tb_cliente values( " +
"@codigo, @nome_cliente, @fone_cliente, @cel_cliente)";
//tenta fazer o insert no banco
try
{
//abre a conexão com o banco de dados
this.conexao_FB.abre_Conexao();
//cria uma nova instancia para FbDataAdapter passando como
//parâmetos a string com o comando SQL e a conexão com o banco de dados
this.adapt = new FbDataAdapter(sql_Insert, this.conexao_FB.get_Conexao());
//limpa os parâmetros caso exista
this.adapt.SelectCommand.Parameters.Clear();
// informa para o FbDataAdapter quais são os conteudos de cada
//parâmetro
// obs: o código esta como null devido que o banco de dados
//está configurado para auto incremento
this.adapt.SelectCommand.Parameters.Add("@codigo", null);
this.adapt.SelectCommand.Parameters.Add("@nome_cliente", tx_nome_cliente.Text);
this.adapt.SelectCommand.Parameters.Add("@fone_cliente", tx_fone_cliente.Text);
this.adapt.SelectCommand.Parameters.Add("@cel_cliente", tx_celular_cliente.Text);
// executa o FbDataAdapter com o comando ExecuteNonQuery
this.adapt.SelectCommand.ExecuteNonQuery();
//mensagem para cadastro OK
MessageBox.Show("Cadastro ok", "Atenção", MessageBoxButtons.OK, MessageBoxIcon.Information);
}
// caso de algum erro
catch (Exception er)
{
// mensagem de erro
MessageBox.Show("Erro ao fazer inclusão: " + er.Message, "Atenção", MessageBoxButtons.OK,
MessageBoxIcon.Error);
}
//fecha a conexao com o banco de dados
finally
{
this.conexao_FB.fecha_Conexao();
}
}
Uma observação sobre o comando this.adapt.SelectCommand.Parameters.Add(),
a forma como foi apresentada é apenas uma das maneiras de se utilizar esse
comando para fazer uma comunicação com o banco de dados, existem várias outras
formas como o exemplo abaixo: this.adapt.SelectCommand.Parameters.Add("@codigo", FbDbType.Integer);
this.adapt.SelectCommand.Parameters[0].Value = null;
Dessa forma, você está informando que o parâmetro "@codigo", é do tipo
Integer. Na segunda linha é informado que na possição 0 do, digamos assim,
“array de parametros”, o valor é null.
Bom, agora que já temos como
cadastrar os dados no banco, podemos partir para a parte de Atualização dos
Dados. Para não estender muito, vamos fazer uma atualização de acordo com o Nome
do Cliente.
No botão Atualizar, de dois clique, e informe o código
conforme abaixo: /// <SUMMARY>
/// Atualiza os dados do Cliente
/// A atualização será feita através do nome do cliente
/// </SUMMARY>
private void bt_atualizar_Click(object sender, EventArgs e)
{
string sql_Update = "update tb_cliente set " +
"nome_cliente = @nome, fone_cliente = @fone, celular_cliente = @cel " +
"where nome_cliente = @nome";
//tenta fazer o insert no banco
try
{
//abre a conexão com o banco de dados
this.conexao_FB.abre_Conexao();
//cria uma nova instancia para FbDataAdapter passando como
//parâmetro a string com o comando SQL e a conexão com o banco de dados
this.adapt = new FbDataAdapter(sql_Update, this.conexao_FB.get_Conexao());
//limpa os parâmetros caso exista algum
this.adapt.SelectCommand.Parameters.Clear();
// informa para o FbDataAdapter quais são os conteudos de cada parâmetro
this.adapt.SelectCommand.Parameters.Add("@nome", tx_nome_cliente.Text);
this.adapt.SelectCommand.Parameters.Add("@fone", tx_fone_cliente.Text);
this.adapt.SelectCommand.Parameters.Add("@cel", tx_celular_cliente.Text);
// executa o FbDataAdapter com o comando ExecuteNonQuery e retorna o total de linhas afetadas
int numero = this.adapt.SelectCommand.ExecuteNonQuery();
//mensagem
MessageBox.Show("Atualização ok: " + numero.ToString(), "Atenção", MessageBoxButtons.OK,
MessageBoxIcon.Information);
}
// caso de algum erro
catch (Exception er)
{
// mensagem de erro
MessageBox.Show("Erro ao fazer atualização: " + er.Message, "Atenção",
MessageBoxButtons.OK, MessageBoxIcon.Error);
}
//fecha a conexão com o banco de dados
finally
{
this.conexao_FB.fecha_Conexao();
}
}
Não existe muita diferença dos comando de inserir para o atualizar. E
novamente repetido que existem outras formas de se fazer essa comunicação com o
banco, e que o exemplo da outra forma citado acima, também vale para essa
atualização, bastando fazer os ajustes necessários.
No botão Deletar, de
dois clique, e informe o código conforme abaixo: /// <SUMMARY>
/// Exclui Cliente
/// Exclui um cliente conforme o nome informado
/// </SUMMARY>
private void bt_deletar_Click(object sender, EventArgs e)
{
string sql_Delete = "delete from tb_cliente where nome_cliente = @nome";
//tenta fazer o insert no banco
try
{
//abre a conexão com o banco de dados
this.conexao_FB.abre_Conexao();
//cria uma nova instancia para FbDataAdapter passando como
//parâmetro a string com o comando SQL e a conexão com o banco de dados
this.adapt = new FbDataAdapter(sql_Delete, this.conexao_FB.get_Conexao());
//limpa os parâmetros caso exista algum
this.adapt.SelectCommand.Parameters.Clear();
// informa para o FbDataAdapter quais são os conteudos de cada parâmetro
this.adapt.SelectCommand.Parameters.Add("@nome", tx_nome_cliente.Text);
// executa o FbDataAdapter com o comando ExecuteNonQuery e retorna o total de linhas afetadas
int numero = this.adapt.SelectCommand.ExecuteNonQuery();
//mensagem
MessageBox.Show("Clientes Excluídos: " + numero.ToString(), "Atenção", MessageBoxButtons.OK,
MessageBoxIcon.Information);
}
// caso de algum erro
catch (Exception er)
{
// mensagem de erro
MessageBox.Show("Erro ao fazer exclusão: " + er.Message, "Atenção",
MessageBoxButtons.OK, MessageBoxIcon.Error);
}
//fecha a conexao com o banco de dados
finally
{
this.conexao_FB.fecha_Conexao();
}
}
Novamente a mesma observação feita para a Inserção e Atualização.
Agora, após ter cadastrado, atualizado e apagado um cliente, podemos
partir para a consulta de clientes.
Nessa parte será introduzido o objeto
DataReader, conforme explicado nos tópicos anteriores, é nele que ficará os
resultados da consulta.
A consulta será feita também pelo nome do cliente,
usando a clausula Like do SQL. No botão Consultar, de dois clique, e
informe o código conforme abaixo: /// <SUMMARY>
/// Realiza a busca pelos dados do cliente
/// através do nome
/// </SUMMARY>
private void bt_consultar_Click(object sender, EventArgs e)
{
string sql_Select = "select nome_cliente, fone_cliente, celular_cliente " +
"from tb_cliente " +
"where nome_cliente like @nome";
//tenta fazer o insert no banco
try
{
//abre a conexão com o banco de dados
this.conexao_FB.abre_Conexao();
//cria uma novo instancia pra FbDataAdapter passando como
//parâmetro a string com o comando SQL e a conexão com o banco de dados
this.adapt = new FbDataAdapter(sql_Select, this.conexao_FB.get_Conexao());
//limpa os parâmetros caso exista algum
this.adapt.SelectCommand.Parameters.Clear();
// informa para o FbDataAdapter quais são os conteudos de cada parâmetro
this.adapt.SelectCommand.Parameters.Add("@nome", "%" + tx_nome_cliente.Text + "%" );
// executa o FbDataAdapter com o comando ExecuteReader e
// retorna os dados para dentro do FbDataReader
this.reader = this.adapt.SelectCommand.ExecuteReader();
//realiza a leitura dos dados
while (this.reader.Read())
{
tx_nome_cliente.Text = this.reader[0].ToString();
tx_fone_cliente.Text = this.reader[1].ToString();
tx_celular_cliente.Text = this.reader[2].ToString();
}
//Importante: sempre feche o FbDataReader após fazer leituras
this.reader.Close();
}
// caso de algum erro
catch (Exception er)
{
// mensagem de erro
MessageBox.Show("Erro ao fazer leitura dos dados: " + er.Message, "Atenção",
MessageBoxButtons.OK, MessageBoxIcon.Error);
}
//fecha a conexao com o banco de dados
finally
{
this.conexao_FB.fecha_Conexao();
}
}
Caso seja uma consulta que irá retornar apenas um dado, como por exemplo o
nome do cliente, aconselho utilizar ExecuteScalar, pois é mais rápido do que um
ExecuteReader.
Para se realizar uma consulta que retorne mais de um dado,
deve-se utilizar ExecuteReader conforme o código acima.
Para realizar a
leitura dos dados, utilizo o comando que todo programador conhece, WHILE, que
enquanto tiver dados dentro do this.reader, ele continuará passando as
informações para os campos. Mas observe que, da forma que foi feito, caso exista
mais de um cliente com o mesmo nome, os dados serão sobrepostos.
Deve-se
tomar muito cuidado ao utilziar esse componente, pois caso você não o feche, irá
ocorrer um erro, então, sempre que utilizar, feche com o comando
this.reader.Close().
Conforme demostrei acima, temos várias
formas para interagir com os dados dentro de um banco.
Os exemplos são
apenas para mostrar uma das maneiras de utilização dos comandos, e nesse caso,
não nos importamos com a regra de negócios e nem a validação dos campos.
Um exemplo adicional
Irei demonstrar agora, de forma rápida, como podemos trabalhar com um
componente DataGridView, mas lembrando que é apenas um exemplo rápido, para
poder saber como iniciar um trabalho com esse componente.
Acrescentei ao
formulário um componente DataGridView, e dei o nome de dg_dados, acrescentei
também um botão para que assim que for clicado, ira carregar o DataGridView com
os dados da consulta.
fig. 7: Layout
2
Veja:
/// <SUMMARY>
/// Carrega os dados no DataGridView
/// </SUMMARY>
private void bt_dataSet_Click(object sender, EventArgs e)
{
//cria um DataTable para carregar os dados da consulta
DataTable dataTable = new DataTable();
string sql_Select = "select * " +
"from tb_cliente ";
//tenta fazer o insert no banco
try
{
//abre a conexão com o banco de dados
this.conexao_FB.abre_Conexao();
//cria uma nova instancia pra FbDataAdapter passando como
//parâmetro
// a string com o comando SQL e a conexão com o banco de
//dados
this.adapt = new FbDataAdapter(sql_Select,this.conexao_FB.get_Conexao());
//limpa os parâmetros caso exista algum
this.adapt.SelectCommand.Parameters.Clear();
//executa a consulta
this.adapt.SelectCommand.ExecuteNonQuery();
//preenche o dataTable com os dados da consulta
this.adapt.Fill(dataTable);
// preenche o DataGridView com os dados
this.dg_dados.DataSource = dataTable;
}
// caso de algum erro
catch (Exception er)
{
// mensagem de erro
MessageBox.Show("Erro ao fazer leitura dos dados: " + er.Message, "Atenção",
MessageBoxButtons.OK, MessageBoxIcon.Error);
}
//fecha a conexao com o banco de dados
finally
{
this.conexao_FB.fecha_Conexao();
}
}
Conclusão
Chegamos então ao final desse Artigo sobre Utilização do SGBD FireBird 2.0
com o ADO.NET, onde podemos ver de forma básica, como fazer para comunicar e
trocar informações com o banco de dados, além de conhecer um pouco da parte
teórica, que é muito importante para o desenvolvimento correto de uma aplicação.
Referências
http://www.linhadecodigo.com.br/artigos.asp?id_ac=296&pag=1
http://www.linhadecodigo.com.br/artigos.asp?id_ac=435&sub=0
http://www.linhadecodigo.com.br/artigos.asp?id_ac=216
http://linhadecodigo.com.br/artigos.asp?id_ac=1254&pag=1
http://www.microsoft.com/brasil/msdn/adonet/default.mspx
http://msdn2.microsoft.com/pt-br/default.aspx
- Introdução ao Morfik-Uma solução para vários seguimentosDelphi
- O DBA de Alta PerformanceFirebird
- Passo a passo como acessar o banco de dados FireBird usando C#.Net, FireBird .Net Data Provider...C#
- 2º Firebird Developers Day - Acompanhe aqui como foi o eventoFirebird
- Criando um aplicação em Shell-Script acessando um Bco Interbase/FirebirdLinux
