 |
| Sala com servidores de banco de dados futurístico. |
Índice
Introdução
Nesse post iremos abordar sobre banco de dados relacional em Delphi, com projeto exemplo e código fonte completo.
Trabalhar com bancos de dados relacionais é uma das habilidades mais importantes para desenvolvedores que criam aplicações que gerenciam e manipulam dados. Neste artigo, vamos explorar os conceitos de banco de dados relacional, a modelagem de dados e a criação de relacionamentos, além de apresentar exemplos práticos de implementação em Delphi.
Introdução aos Conceitos de Banco de Dados Relacional em Delphi
Um banco de dados relacional organiza os dados em tabelas, que são formadas por linhas e colunas. Cada tabela representa uma entidade, como "Clientes" ou "Pedidos". As tabelas podem ser relacionadas entre si através de chaves primárias e estrangeiras.
- Chave Primária (Primary Key): Um campo (ou combinação de campos) que identifica unicamente cada registro em uma tabela.
- Chave Estrangeira (Foreign Key): Um campo que cria uma ligação entre duas tabelas, referenciando a chave primária de outra tabela.
Esses relacionamentos permitem consultas complexas e manipulação eficiente de dados, mantendo a integridade e consistência dos dados.
Modelagem de Dados e Criação de Relacionamentos
A modelagem de dados é o processo de definir a estrutura de um banco de dados. Envolve a criação de tabelas, a definição de campos e tipos de dados, e a criação de relacionamentos entre tabelas.
Exemplo de Modelagem de Dados
Suponha que estamos desenvolvendo um sistema de gerenciamento de pedidos. Teríamos pelo menos duas tabelas: Customers (Clientes) e Orders (Pedidos).
CREATE TABLE Customers (
CustomerID VARCHAR(5) PRIMARY KEY,
CompanyName VARCHAR(40),
ContactName VARCHAR(30)
);
CREATE TABLE Orders (
OrderID INT PRIMARY KEY,
OrderDate DATE,
CustomerID VARCHAR(5),
ShipName VARCHAR(40)
FOREIGN KEY (CustomerID) REFERENCES Customers(CustomerID)
);
Neste exemplo, CustomerID é a chave primária na tabela Customers e uma chave estrangeira na tabela Orders. Isso cria um relacionamento entre as duas tabelas, permitindo que cada pedido(order) seja associado a um cliente(customer) específico. Essa amarração entre a chave primaria de uma tabela com a chave estrangeira de outra que é característica de um banco de dados relacional.
Alguns dos bancos de dados relacionais mais utilizados em Delphi:
- InterBase: Desenvolvido pela Embarcadero, o InterBase é um banco de dados relacional leve e de alta performance, especialmente integrado com Delphi. Ele é conhecido por seu suporte a transações, replicação e criptografia.
- Firebird: Um fork do InterBase, o Firebird é um sistema de banco de dados relacional de código aberto que oferece uma solução robusta e de baixo custo. Ele é compatível com Delphi e oferece boa escalabilidade e suporte a transações.
- MySQL: Um dos bancos de dados relacionais de código aberto mais populares, o MySQL é amplamente utilizado em várias plataformas. Delphi oferece suporte para MySQL através de componentes FireDAC e outros drivers de terceiros.
- PostgreSQL: Outro banco de dados relacional de código aberto conhecido por suas funcionalidades avançadas e conformidade com padrões SQL. Delphi pode se conectar ao PostgreSQL usando componentes FireDAC e outros conectores.
- Microsoft SQL Server: Um dos sistemas de gerenciamento de banco de dados relacionais mais utilizados em ambientes corporativos. Delphi oferece suporte robusto para SQL Server através de componentes FireDAC e ADO.
- SQLite: Um banco de dados relacional leve e embutido que é amplamente utilizado em aplicações móveis e desktop. Delphi possui suporte integrado para SQLite através da biblioteca FireDAC.
- Oracle Database: Um sistema de gerenciamento de banco de dados relacional empresarial, conhecido por sua escalabilidade e funcionalidades avançadas. Delphi suporta Oracle Database através de FireDAC e outros drivers.
- DB2: Desenvolvido pela IBM, o DB2 é um banco de dados relacional que oferece suporte a grandes volumes de dados e alta performance. Delphi pode se conectar ao DB2 utilizando componentes específicos.
- MariaDB: Um fork do MySQL, o MariaDB é um banco de dados relacional de código aberto que é completamente compatível com MySQL e oferece melhorias e recursos adicionais. Delphi pode se conectar ao MariaDB através de FireDAC e outros drivers.
- Sybase (SAP ASE): Um banco de dados relacional que oferece soluções de gerenciamento de dados para aplicações empresariais. Delphi pode se conectar ao Sybase através de FireDAC e outros drivers de banco de dados.
Esses bancos de dados cobrem uma ampla gama de necessidades, desde soluções de código aberto até soluções empresariais robustas, e são amplamente utilizados com Delphi para criar aplicações de desktop e servidor.
Exemplos Práticos de Implementação em Delphi
Delphi oferece componentes poderosos para trabalhar com bancos de dados relacionais. Vamos ver como podemos implementar a modelagem de dados acima em Delphi usando o componente TFDQuery da biblioteca FireDAC.
Passo 1: Configurando o Projeto
Criar um Novo Projeto
- Abrir o Delphi: Abra o Delphi e crie um novo projeto VCL Forms Application.
- Salve o projeto com o nome que desejar.
Adicionar Componentes
No formulário principal, adicione os seguintes componentes:
- TFDConnection (1): Para conectar ao banco de dados.
- TListBox (1): Para visualizar os dados das tabelas.
- TButton (3): Para executar comandos e consultar os dados.
Passo 2: Configurando a Conexão com o Banco de Dados
Primeiro, precisamos configurar a conexão com o banco de dados. Supondo que estamos usando um banco de dados SQLite, o código para configurar a conexão seria algo assim:
uses
FireDAC.Comp.Client, FireDAC.Stan.Def, FireDAC.Stan.Async, FireDAC.DApt, FireDAC.UI.Intf,
FireDAC.VCLUI.Wait, FireDAC.Phys.SQLite, FireDAC.Phys.SQLiteDef;
procedure TForm1.SetupConnection;
begin
//Driver de conexão
FDConnection1.Params.DriverID := 'SQLite';
//Caminho do banco de dados
FDConnection1.Params.Database := 'C:\Users\Public\Documents\Embarcadero\Studio\22.0\Samples\data\FDDemo.sdb';
//Habilita a conexão
FDConnection1.Connected := True;
end;
Explicação do código:
- SetupConnection: Foi criada uma procedure chamada SetupConnection que é a responsável por configurar a conexão com o banco de dados.
- DriverID: Foi definido o driver de conexão do banco de dados, no caso SQLite.
- Database: Foi definido o banco de dados a ser utilizado, no meu caso o demo disponibilizado pelo Delphi fica no diretório 'C:\Users\Public\Documents\Embarcadero\Studio\22.0\Samples\data\FDDemo.sdb' que foi onde eu instalei o Delphi. Veja certinho em que pasta está o seu.
- Connected: Habilita a conexão de banco de dados passando True.
Se você está utilizando o Delphi 11 assim como eu, o Delphi já fornece um banco de dados demo para o SQLite já com as tabelas Customers e Orders existentes. Vamos utilizar esse banco de dados para facilitar nosso exemplo. Caso você não tenha o banco de dados FDDemo.sdb, eu estarei disponibilizando pelo github juntamente com o código fonte completo.
Para visualizar se o seu Delphi possui esse banco de dados, abra a aba Data Explores e veja se dentro do nó FireDAC existe o banco de dados SQLite database, expanda o nó e veja se dentro dele existe SQLite demo, expanda o nó mais uma vez e veja se dentro do nó Tables existe as tabelas Customers e Orders.
Veja a ilustração abaixo:
 |
| Componente do FireDAC para conexão com SQLite. |
Passo 3: Executando Consultas SQL
Depois de configurar a conexão, podemos usar o componente TFDQuery para executar consultas SQL.
Exemplo: Selecionando Dados
procedure TForm1.LoadCustomers;
var
FDQuery: TFDQuery;
begin
FDQuery := TFDQuery.Create(nil);
try
FDQuery.Connection := FDConnection1;
FDQuery.SQL.Text := 'SELECT * FROM Customers';
FDQuery.Open;
ListBox1.Clear;
ListBox1.Items.Add('Código Nome do Contato'); //Formata o título a ser exibido de acordo com os dados
while not FDQuery.Eof do
begin
//Alimenta o listbox com os dados consultados
ListBox1.Items.Add(FDQuery.FieldByName('CustomerID').AsString + ' - ' +FDQuery.FieldByName('ContactName').AsString);
FDQuery.Next;
end;
finally
FDQuery.Free;
end;
end;
Explicação do Código
- LoadCustomers: Procedure criada para inserir dados na tabela Customers;
- TFDQuery.Create(nil): É o comando que cria a instância do objeto FDQuery;
- FDQuery: a linha FDQuery: TFDQuery declara o componente FDQuery dinamicamente, para executar as consultas;
- FDQuery.Connection: Recebe a conexão com o banco de dados;
- FDQuery.SQL.Text: Recebe a instrução de consulta da tabela Customers;
- FDQuery.Open: Executa a consulta na tabela Customers;
- ListBox1.Clear: Limpa os dados do ListBox para receber os dados da consulta;
- ListBox1.Items.Add: Comando para adicionar linhas no ListBox, ou seja, o título e os resultados da consulta;
- while: Executa um laço de repetição até que todos os registros da consulta sejam adicionados no ListBox;
- FDQuery.Next: Move para o próximo registro da consulta;
- FDQuery.Free: Libera o componente da memória;
Perceba que o comando SELECT * FROM Customers é o comando executado para consultar todos os registros da tabela Customers.
Passo 4: Inserindo Dados
procedure TForm1.AddCustomer(CustomerID, CompanyName, ContactName : String);
var
FDQuery: TFDQuery;
begin
FDQuery := TFDQuery.Create(nil);
try
FDQuery.Connection := FDConnection1;
FDQuery.SQL.Text := 'INSERT INTO Customers (CustomerID, CompanyName, ContactName) ' +
'VALUES (:CustomerID, :CompanyName, :ContactName)';
FDQuery.ParamByName('CustomerID').AsString := CustomerID;
FDQuery.ParamByName('CompanyName').AsString := ContactName;
FDQuery.ParamByName('ContactName').AsString := ContactName;
FDQuery.ExecSQL;
ShowMessage('O cliente '+ ContactName + ' foi inserido.');
LoadCustomers;//Consulta para exibir o cliente que acabou de ser inserido
finally
FDQuery.Free;
end;
end;
Explicação do código
- FDQuery: a linha FDQuery: TFDQuery declara o componente FDQuery dinamicamente, para executar as consultas;
- TFDQuery.Create(nil): É o comando que cria a instância do objeto FDQuery;
- FDQuery.Connection: Recebe a conexão com o banco de dados;
- FDQuery.SQL.Text: Recebe a instrução de inserção na tabela Customers;
- FDQuery.ParamByName('CustomerID').AsString: Recebe o campo CustomerID que será salvo na tabela Customers.
- FDQuery.ParamByName('CompanyName').AsString: Recebe o campo CompanyNameque será salvo na tabela Customers.
- FDQuery.ParamByName('ContactName').AsString: Recebe o campo ContactName será salvo na tabela Customers.
- FDQuery.ExecSQL: É o comando que executa a instrução de inserção, ou seja, persiste os dados no banco de dados.
- ShowMessage: Comando para exibir mensagens, nesse caso irá exibir a mensagem dizendo que o cliente 'x' foi inserido.
- LoadCustomers: Procedure que executa a consulta na tabela Customers, para exibir os registros da tabela, inclusive o que acabou de ser inserido.
- FDQuery.Free: Libera o componente da memória;
Passo 5: Relacionando Dados
Vamos criar uma consulta que junta dados de Customers e Orders.
procedure TForm1.LoadCustomerOrders(CustomerID: String);
var
FDQuery: TFDQuery;
//procedimento para formatar o título que será exibido de acordo com os dados
procedure InserirTitulo(ListBox : TListBox);
var
Titulo : String;
i: Integer;
begin
Titulo := 'Data Estabelecimento ';
for i := 0 to Length(FDQuery.FieldByName('ShipName').AsString) - 14 do
Insert(' ', Titulo, 29);
Titulo := Titulo + 'Nome do Contato';
ListBox.Items.Add(Titulo);
end;
begin
FDQuery := TFDQuery.Create(nil);
try
FDQuery.Connection := FDConnection1;
FDQuery.SQL.Text := 'SELECT Orders.OrderID, Orders.OrderDate, Orders.ShipName, Customers.ContactName ' +
'FROM Orders ' +
'INNER JOIN Customers ON Orders.CustomerID = Customers.CustomerID ' +
'WHERE Orders.CustomerID = :CustomerID';
FDQuery.ParamByName('CustomerID').AsString := CustomerID;
FDQuery.Open;
ListBox1.Clear;
InserirTitulo(ListBox1);
while not FDQuery.Eof do
begin
//Alimenta o listbox com os dados consultados
ListBox1.Items.Add(FDQuery.FieldByName('OrderDate').AsString + ' - ' + FDQuery.FieldByName('ShipName').AsString +' - '+ FDQuery.FieldByName('ContactName').AsString);
FDQuery.Next;
end;
finally
FDQuery.Free;
end;
end;
Explicação do código:
- FDQuery: a linha FDQuery: TFDQuery declara o componente FDQuery dinamicamente, para executar as consultas;
- TFDQuery.Create(nil): É o comando que cria a instância do objeto FDQuery;
- InserirTitulo(ListBox : TListBox): É uma procedure que foi criada para criar o título dos dados que serão exibidos no ListBox, esse código foi inserido apenas para melhor identificação visual de cada campo das tabelas que serão exibidos.
- FDQuery.Connection: Recebe a conexão com o banco de dados;
- FDQuery.SQL.Text: Recebe a instrução de consulta da tabela Customers relacionada com a tabela Orders ;
- FDQuery.ParamByName('CustomerID').AsString: Passa o campo CustomerID como parâmetro de consulta para o comando sql, ou seja, a consulta só trará resultados com o CustomerID consultado.
- FDQuery.Open: Executa a consulta na tabela Customers;
- ListBox1.Clear: Limpa os dados do ListBox para receber os dados da consulta;
- InserirTitulo(ListBox1): Insere o título no ListBox1;
- while: Executa um laço de repetição até que todos os registros da consulta sejam adicionados no ListBox;
- FDQuery.Free: Libera o componente da memória;
Perceba que o comando abaixo é o comando SQL que faz o relacionamento entre as tabelas Customers e Order, através da do comando INNER JOIN que amarra o campo CustomerID da tabela Customers com o campo CustomerID da tabela Orders.
'SELECT Orders.OrderID, Orders.OrderDate, Orders.ShipName, Customers.ContactName ' +
'FROM Orders ' +
'INNER JOIN Customers ON Orders.CustomerID = Customers.CustomerID ' +
'WHERE Orders.CustomerID = :CustomerID'
Veja abaixo a ilustração do projeto:
 |
| Ilustração do projeto. |
Código fonte do exemplo
Você pode fazer o download do exemplo do projeto através do repositório do github:
https://github.com/Gisele-de-Melo/SQLite
Esse blog é voltado para programação em Delphi e não tem a intensão de te ensinar comandos SQL de qualquer tipo de banco de dados dados, portanto, procure estudar sempre, cada banco de dados tem suas particularidades.
Caso tenha gostado de trabalhar com o SQLite, visite entre no link a seguir que você encontrará conteúdo exclusivo e toda documentação: https://www.sqlite.org/
Conclusão
Trabalhar com bancos de dados relacionais em Delphi é uma tarefa essencial para muitos desenvolvedores. Com a compreensão dos conceitos básicos de bancos de dados relacionais, a modelagem de dados e a criação de relacionamentos, você pode criar aplicações robustas e eficientes. O uso de componentes como TFDQuery simplifica a interação com o banco de dados e permite executar consultas SQL de maneira eficaz. Seguindo as práticas recomendadas e utilizando as ferramentas apropriadas, você pode garantir que suas aplicações sejam escaláveis, performáticas e fáceis de manter.
Nenhum comentário:
Postar um comentário