Você já precisou de uma coluna no banco de dados que calculasse seu valor automaticamente com base em outras colunas? Com o Entity Framework é possível criar colunas calculadas diretamente no modelo de dados, utilizando o método “HasComputedColumnSql”. Neste artigo veremos como implementar este tipo de coluna.
O que são colunas calculadas?
Colunas calculadas são um recurso poderoso de bancos de dados que permitem derivar valores dinamicamente com base em outras colunas da mesma tabela, usando expressões SQL. Em vez de armazenar diretamente os dados, o banco de dados calcula o valor da coluna automaticamente quando necessário, com base nas regras definidas
Benefícios das colunas calculadas
Colunas calculadas trazem uma série de vantagens que podem melhorar significativamente a eficiência e a manutenção do banco de dados, bem como a performance geral do sistema. Vamos explorar os principais benefícios que elas oferecem:
Redução de redundância: colunas calculadas evitam a necessidade de armazenar dados que podem ser calculados a partir de outras informações já presentes na tabela. Isso não só economiza espaço de armazenamento, mas também garante que os dados derivados estejam sempre em sincronia com os dados base, eliminando a possibilidade de inconsistências.
Simplificação de lógica de negócios: ao centralizar cálculos complexos no banco de dados, colunas calculadas permitem que essa lógica seja definida e mantida em um único lugar. Isso simplifica a manutenção do código, reduzindo a complexidade do lado do aplicativo e facilitando futuras alterações nas regras de negócio.
Performance: quando configuradas corretamente, colunas calculadas podem melhorar a performance de consultas ao evitar cálculos repetidos no lado do aplicativo. Como o banco de dados é otimizado para lidar com operações complexas de maneira eficiente, delegar essas operações para colunas calculadas pode resultar em respostas mais rápidas e menor carga sobre os recursos do servidor de aplicação.
Em resumo, o uso de colunas calculadas no banco de dados pode resultar em uma arquitetura mais limpa, eficiente e fácil de manter, ao mesmo tempo em que melhora a performance do sistema.
Como funcionam as colunas calculadas
Uma coluna calculada é uma coluna cujo valor é derivado de uma expressão envolvendo outras colunas na mesma tabela. No Entity Framework, isso pode ser configurado usando o método “HasComputedColumnSql” no “ModelBuilder”. A expressão SQL é usada para definir a fórmula da coluna calculada. Essa coluna pode ser armazenada (stored: true) ou não armazenada (stored: false).
Stored: true: o valor da coluna calculada é armazenado no banco de dados, sendo recalculado apenas quando uma das colunas de base é atualizada. Isso pode melhorar a performance de leitura.
Stored: false: o valor da coluna calculada não é armazenado no banco de dados, sendo recalculado a cada consulta. Isso economiza espaço de armazenamento, mas pode ser menos eficiente em termos de performance de leitura.
Exemplo prático
Para implementar um exemplo de colunas calculadas usando o método “HasComputedColumnSql”, utilizaremos um projeto de API construído em ASP.NET. Antes de começar, certifique-se de que os pacotes necessários do Entity Framework Core estejam instalados em seu projeto e que a conexão com o banco de dados esteja corretamente configurada. Você pode instalar os pacotes necessários através do Package Manager Console, usando os seguintes comandos:
Install-Package Microsoft.EntityFrameworkCore
Install-Package Microsoft.EntityFrameworkCore.SqlServer
Install-Package Microsoft.EntityFrameworkCore.Design
Install-Package Microsoft.EntityFrameworkCore.Tools
Após isso, vamos definir a entidade “Produto” com as propriedades necessárias, incluindo a coluna calculada que, no caso, será “ValorTotalEstoque”
public class Produto
{
public int Id { get; set; }
public string Nome { get; set; }
public decimal PrecoUnitario { get; set; }
public int QuantidadeEmEstoque { get; set; }
public decimal ValorTotalEstoque { get; set; }
}
Defina uma classe para o contexto do banco de dados herdando de DbContext:
using ColunasCalculadasEF.Models;
using Microsoft.EntityFrameworkCore;
public class ApplicationDbContext : DbContext
{
public ApplicationDbContext(DbContextOptions<ApplicationDbContext> options)
: base(options)
{
}
public DbSet<Produto> Produtos { get; set; }
protected override void OnModelCreating(ModelBuilder modelBuilder)
{
modelBuilder.Entity<Produto>()
.Property(p => p.ValorTotalEstoque)
.HasComputedColumnSql("[PrecoUnitario] * [QuantidadeEmEstoque]", stored: true);
}
}
Na configuração do contexto do banco de dados, utilizamos o método “OnModelCreating” para definir a lógica de criação do modelo. Dentro deste método, configuramos a entidade “Produto” especificando que a propriedade “ValorTotalEstoque” é uma coluna calculada. Utilizamos o método “HasComputedColumnSql” para definir a expressão SQL “[PrecoUnitario] * [QuantidadeEmEstoque]”, que calcula o valor de “ValorTotalEstoque” multiplicando os valores das colunas “PrecoUnitario” e “QuantidadeEmEstoque”. O parâmetro “stored: true”, como citado anteriormente, indica que o valor da coluna calculada será armazenado no banco de dados, o que melhora a performance de leitura ao evitar novos cálculos frequentes.
Para demonstrar a utilização das colunas calculadas com o Entity Framework, vamos criar um controller de produtos que permitirá buscar todos os produtos e adicionar novos produtos ao banco de dados:
using ColunasCalculadasEF.Models;
using Microsoft.AspNetCore.Mvc;
namespace ColunasCalculadasEF.Controllers
{
[Route("api/[controller]")]
[ApiController]
public class ProductController : ControllerBase
{
private readonly ApplicationDbContext _context;
public ProductController(ApplicationDbContext context)
{
_context = context;
}
[HttpGet]
public IActionResult BuscarTodos()
{
var produtos = _context.Produtos.ToList();
return Ok(produtos);
}
[HttpPost]
public IActionResult Criar(Produto produtoCriar)
{
_context.Produtos.Add(produtoCriar);
_context.SaveChanges();
return Ok(produtoCriar);
}
}
}
Ao iniciar nossa aplicação e adicionar um produto ao banco de dados, perceba que a propriedade “ValorTotalEstoque” não precisa ser preenchida, pois ela será calculada diretamente no banco:
{
"id": 0,
"nome": "Notebook",
"precoUnitario": 1800,
"quantidadeEmEstoque": 10,
"valorTotalEstoque": 0
}
A resposta que recebemos é a seguinte:
{
"id": 1,
"nome": "Notebook",
"precoUnitario": 1800,
"quantidadeEmEstoque": 10,
"valorTotalEstoque": 18000
}
No banco de dados o valor é registrado da seguinte forma:
Neste exemplo, quando enviamos uma requisição para adicionar um novo produto, podemos ver que a coluna calculada “ValorTotalEstoque” é automaticamente preenchida pelo banco de dados. Embora a propriedade seja enviada com o valor “0” na requisição, o valor final é calculado como “precoUnitario * quantidadeEmEstoque” e atualizado pelo banco de dados.
Acelere a sua carreira conosco!
Se você é Desenvolvedor .NET Júnior e quer acelerar sua carreira até nível Pleno com salário de R$7k+, ou mesmo busca a primeira vaga, conheça a Mentoria .NET Start: Clique aqui
Se é Desenvolvedor .NET Pleno ou Sênior e quer virar referência técnica em sua equipe e mercado, com salário de R$10k+, conheça a Mentoria .NET Expert: Clique aqui
Conclusão
Colunas calculadas no Entity Framework Core oferecem uma maneira eficiente de gerenciar cálculos automáticos diretamente no banco de dados. Elas ajudam a reduzir redundâncias, simplificar a lógica de negócios e melhorar a performance das consultas. Com este guia, você pode implementar e beneficiar-se das colunas calculadas em suas aplicações .NET, garantindo que seus dados sejam gerenciados de forma eficiente e consistente.