✔ Programação GLOBAL®: Paradox (Delphi) | Códigos Avançados - Realizar consulta com filtro - Explorando Consultas em Delphi com Parâmetros e Melhorias de Performance - Advanced Code: Querying with Filters & Enhancing Performance in Delphi with Parameters

Paradox (Delphi) | Códigos Avançados - Realizar consulta com filtro - Explorando Consultas em Delphi com Parâmetros e Melhorias de Performance - Advanced Code: Querying with Filters & Enhancing Performance in Delphi with Parameters

A linguagem Delphi continua sendo uma escolha robusta para o desenvolvimento de aplicações que exigem alta performance e integração com bancos de dados. O código apresentado demonstra como realizar consultas parametrizadas em uma tabela de um banco Paradox usando a classe TQuery. Neste artigo, vamos detalhar sua funcionalidade, discutir suas aplicações, apresentar aspectos avançados e propor melhorias em versões alternativas do código.

procedure QueryWithFilter;
var
Query: TQuery;
begin
Query := TQuery.Create(nil);
try
Query.DatabaseName := 'ParadoxDB';
Query.SQL.Text := 'SELECT * FROM NewTable WHERE Name LIKE :NameFilter';
Query.Params.ParamByName('NameFilter').AsString := 'Name%';
Query.Open;

while not Query.Eof do
begin
Writeln('ID: ', Query.FieldByName('ID').AsInteger);
Writeln('Name: ', Query.FieldByName('Name').AsString);
Writeln('Date Created: ', Query.FieldByName('DateCreated').AsDateTime);
Query.Next;
end;
except
on E: Exception do
Writeln('Erro na consulta: ', E.Message);
end;
Query.Free;
end;

Análise do Código Original

O código cria uma instância de TQuery para executar uma consulta parametrizada em uma tabela chamada "NewTable". O filtro é aplicado através de um parâmetro :NameFilter, cujo valor inicial é configurado como "Name%" para buscar registros onde o campo "Name" começa com a string "Name". O resultado é percorrido utilizando um laço, exibindo os valores de ID, Name e DateCreated de cada registro. Um bloco try...except trata eventuais exceções, garantindo que erros não interrompam a execução.

A utilização de parâmetros melhora a segurança contra SQL Injection, enquanto a leitura iterativa dos registros torna o processo eficiente para manipulações simples.

Aplicações e Usabilidade

Este código pode ser usado em diversas situações:

Sistemas de gerenciamento de conteúdo (CMS): Consultar usuários ou artigos com base em filtros dinâmicos.
ERP e CRMs: Buscar registros como clientes ou transações com critérios específicos.
Ferramentas administrativas: Analisar logs ou eventos baseados em datas ou padrões de texto.

A flexibilidade oferecida pelo uso de parâmetros torna este modelo essencial para aplicações que necessitam de consultas personalizadas e seguras.

Aspectos Avançados

Apesar de funcional, o código pode ser otimizado em vários aspectos:

Uso de transações: Adicionar controle de transações pode melhorar a integridade dos dados em sistemas críticos.
Gestão de recursos: Utilizar estruturas como try...finally é recomendável para garantir a liberação correta de recursos.
Melhoria de performance: Configurar o FetchOptions para limitar a quantidade de registros lidos pode ser útil para tabelas grandes.

Versão Melhorada com Boas Práticas

procedure QueryWithFilterImproved;
var
Query: TQuery;
begin
Query := TQuery.Create(nil);
try
Query.DatabaseName := 'ParadoxDB';
Query.SQL.Text := 'SELECT ID, Name, DateCreated FROM NewTable WHERE Name LIKE :NameFilter';
Query.Params.ParamByName('NameFilter').AsString := 'Name%';

try
Query.Open;
while not Query.Eof do
begin
Writeln(Format('ID: %d, Name: %s, Date Created: %s',
[Query.FieldByName('ID').AsInteger,
Query.FieldByName('Name').AsString,
DateTimeToStr(Query.FieldByName('DateCreated').AsDateTime)]));
Query.Next;
end;
except
on E: Exception do
Writeln('Erro na consulta: ', E.Message);
end;
finally
Query.Free;
end;
end;

Nesta versão, destacam-se:

Uso de finally para garantir a liberação de recursos.
Seleção de campos específicos para melhorar a performance.
Formatação de saída com Format para maior clareza.

Versão com Abordagem Orientada a Objetos

type
TDatabaseQuery = class
private
FQuery: TQuery;
public
constructor Create(DatabaseName: string);
destructor Destroy; override;
procedure ExecuteQuery(Filter: string);
end;

constructor TDatabaseQuery.Create(DatabaseName: string);
begin
FQuery := TQuery.Create(nil);
FQuery.DatabaseName := DatabaseName;
end;

destructor TDatabaseQuery.Destroy;
begin
FQuery.Free;
inherited;
end;

procedure TDatabaseQuery.ExecuteQuery(Filter: string);
begin
FQuery.SQL.Text := 'SELECT ID, Name, DateCreated FROM NewTable WHERE Name LIKE :NameFilter';
FQuery.Params.ParamByName('NameFilter').AsString := Filter;
try
FQuery.Open;
while not FQuery.Eof do
begin
Writeln(Format('ID: %d, Name: %s, Date Created: %s',
[FQuery.FieldByName('ID').AsInteger,
FQuery.FieldByName('Name').AsString,
DateTimeToStr(FQuery.FieldByName('DateCreated').AsDateTime)]));
FQuery.Next;
end;
except
on E: Exception do
Writeln('Erro na consulta: ', E.Message);
end;
end;

Nesta versão, a consulta é encapsulada em uma classe, promovendo reusabilidade e separação de responsabilidades. O uso de métodos orientados a objetos facilita a manutenção e ampliação da aplicação.

O exemplo original é um ponto de partida eficaz para consultas em Delphi. Contudo, as versões aprimoradas apresentadas neste artigo demonstram como o código pode evoluir para atender melhor às necessidades de desempenho, organização e manutenção em projetos de software modernos. Considerar boas práticas e padrões de projeto é essencial para garantir soluções robustas e escaláveis.

Clique aqui e nos contate via What's App para avaliarmos seus projetos

Envie seus comentários e sugestões e compartilhe este artigo!

brazilsalesforceeffectiveness@gmail.com

Série de Livros nut Project