Desenvolvimento - ASP. NET
db4o - Banco de Dados Orientado a Objetos
Banco de Objetos serão a próxima onda na área de desenvolvimento e a plataforma .Net já dispõe de um excelente banco de dados orientado a objetos, o db4o.
por Cassio R. EskelsenParte I - Introdução
De uns tempos para cá tenho percebido uma procura crescente por ferramentas que facilitem a integração entre o mundo orientado a objetos (a linguagem e o framework) e o mundo relacional (o banco de dados). As tais ferramentas de mapeamento objeto relacional nada mais são do que um "tradutor" entre duas línguas totalmente diferentes.
Em todas as traduções você acaba perdendo as sutilezas de uma língua ou tendo que usar muito mais palavras para expressar um conceito que é relativamente simples na língua de origem. No mapeamento O/R não é diferente: você acaba perdendo uma série de recursos da programação OO, ou tendo que escrever muito mais código para simular no banco de dados algo simples na linguagem (como por exemplo, uma propriedade do tipo array ou o gerenciamento de uma herança).
Particularmente acredito que estaremos em um mundo perfeito quando todos os banco de dados permitirem que você simplesmente pegue seu objeto do jeito que ele está e jogue-o no banco de dados(vou passar a chamar de banco de objetos) sem se preocupar com camadas e mais camadas de código para "traduzir" um objeto em query.
Já existem várias tentativas de se fazer isso, incluindo algumas muito avançadas como o Prevayler (bambooprevalence e xprevail nas encarnações .Net). No entanto, a falta de confiabilidade nos equipamentos e sistema operacional aliadas a uma certa dose de preconceito fazem com que essa solução ainda seja rotulada como "algo para o futuro".
Na outra ponta existem soluções como o LINQ da Microsoft, uma feature que estará disponível oficialmente no C# 3.0 mas que já pode ser testado agora. Não considero que isso seja verdadeiramente uma solução pois misturar conceitos relacionais (selects, wheres, etc) em uma linguagem OO como o C# é o que poderíamos chamar de "código alienígena".
Um banco realmente OO deve permitir que você faça suas
consultas de forma orientada a objetos, como se estivesse pesquisando em uma
Array, List ou qualquer outro container de objetos.
É aqui que se encaixa o
db4o! Claro que existem outras soluções como o Caché, mas prefiro me ater
ao db4o pelo seu custo acessível e por já estar mais integrado a plataforma
.Net
db4objects
O db4objects(db4o) surgiu a alguns anos atrás inicialmente apenas para Java. Com a grande semelhança de código entre o .Net e o Java, foi um pulo para que fosse criada uma versão .Net. Hoje, as versões .Net e Java caminham lado a lado, tendo ambas os mesmos recursos.
Com esse banco você pode desenvolver aplicações WEB, Windows.forms e Compact Framework. Você não precisa instalar nem configurar um servidor de banco de dados. Basta enviar junto com sua aplicação uma pequena dll. Claro que você pode fazer uma aplicação cliente/servidor. O próprio db4o provê recursos para que isso seja feito, mas sempre de uma forma simples, sem a necessidade de ser um PHD em configuração de banco de dados.
O db4o tem um mecanismo de replicação muito útil para quem tem
necessidade por exemplo, de manter bancos off-line parte do tempo e
on-line
o restante (quem desenvolve para forças de venda deve imaginar o que estou
falando!).
Quando falo em db4o, algumas perguntas são inevitáveis:
a) Não tenho problemas de performance? Não. Alguns testes
mostram inclusive que o db4o é muito mais rápido que soluções que envolvam o uso
de Nhibernate por exemplo. Veja benchmarks aqui: http://www.db4o.com/about/productinformation/benchmarks/
b) Ele não é caro como o Caché? Não. A licença do db4o é
open-source dual como a do MySql, ou seja, se você está desenvolvendo para uso
dentro de sua empresa, criando seu website ou desenvolvendo um programa GPL, ele
é gratuito para você.
Mas mesmo que você precise distribuir sua aplicação, o
custo da licença runtime é muito baixo.
db4o na prática
Nesse primeiro artigo sobre o db4o irei listar algumas operações básicas para que você veja a facilidade que é trabalhar com um banco origentado a objetos. Nos artigos seguintes irei mostrar um Membership provider para db4o e dicas de como deixar o trabalho com o db4o mais prático e rápido.
Instalação
Você pode puxar o db4o nesse link: http://www.db4o.com/community/ Os exemplos que farei já serão
baseados na nova versão 5.0.
A instalação não fará nada mais do que
descompactar os arquivos em um diretório.
Você terá a seguinte estrutura de
diretórios
\dll: as dlls do db4o com duas versões: compact framework e
para uso em PC
\doc: help e um excelente tutorial
\src: fontes do db4o e
testes unitários que podem servir de fonte de estudo
Utilização
Para você utilizar o db4o em seus projetos basta referenciar a respectiva dll e adicionar um "using com.db4o"
Criando um database
Não existe no db4o um processo formal de criação do database nem das
respectivas classes. A medida em que você for salvando seus objetos o db4o faz
tudo para você.Em um código que usa o db4o como persistência tudo gira em torno
de ObjectContainer. É o ObjectContainer que irá gravar, ler e alterar seus
dados.
O arquivo de dados do db4o tem normalmente a extensão .yap.
A
primeira operação que faremos é "conectar" no arquivo:
ObjectContainer objectBag = Db4o.OpenFile("arquivo.yap");
Isso abrirá o arquivo (se já existente) ou criará um novo.
Claro que você pode colocá-lo em qualquer diretório em que sua aplicação tenha
direito de acesso/gravação.
Pelo intellisense do Visual Studio você
poderá ver que objectBag tem uma série de métodos e entre eles podemos citar:
Set: grava objetos na base
Get: recupera um objeto da
base procurando-o através de um template
Delete: apaga um
objeto
Query: faz uma pesquisa na base retornando uma lista do tipo
ObjectSet
Query<T>: faz uma pesquisa retornando uma lista
tipada
Commit e Rollback: confirma/anula uma transação (semelhante ao
commit/rollback dos RDBMs)
Inserindo dados
Para nossos testes iremos criar duas classes muito
simples:
public class Autor
{
private string _nome;
private string _email;
public string Nome
{
get { return _nome; }
set { _nome = value; }
}
public string Email
{
get { return _email; }
set { _email = value; }
}
public override string ToString()
{
return this.Nome+"("+this.Email+")";
}
}
public class Livro
{
private Autor _autor;
private string _titulo;
private string _isbn;
public string ISBN
{
get { return _isbn; }
set { _isbn = value; }
}
public string Titulo
{
get { return _titulo; }
set { _titulo = value; }
}
public Autor Autor
{
get { return _autor; }
set { _autor = value; }
}
public override string ToString()
{
return string.Format("Titulo: {0}\nAutor: {1}\nISBN: {2}\n\n", this.Titulo, this.Autor.Nome, this.ISBN);
}
}
Por default, O db4o grava o conteudo de todos os campos. Caso você não
deseja gravar algum campo, você deve marcá-lo
com o atributo
[Transient]
Note que não estou as classes não descendem de nenhuma classe
base, e também não estou implementando nenhuma interface
específica.
Vamos criar uma pequena massa de dados e salvá-los na
base:
static void CriaDados()
{
Autor raul = new Autor();
raul.Nome = "Raul Wazlawick";
raul.Email = "raul@acme.com";
Livro analise = new Livro();
analise.Autor = raul;
analise.ISBN = "8535215646";
analise.Titulo = "Análise e Projetos de Sistemas de Informação Orientados a Objetos";
objectBag.Set(analise);
Autor fabio = new Autor();
fabio.Nome = "Fabio Camara";
fabio.Email = "fabio@acme.com";
Livro dominando = new Livro();
dominando.Autor = fabio;
dominando.Titulo = "Dominando o Visual Studio.Net com C#";
dominando.ISBN = "8575021095";
objectBag.Set(dominando);
Livro cinquentaEOito = new Livro();
cinquentaEOito.Autor = fabio;
cinquentaEOito.Titulo = "58+ Soluções em .Net";
cinquentaEOito.ISBN = "8575021583";
objectBag.Set(cinquentaEOito);
}
Em ordem o que fiz:
- Criei uma nova instância de Autor (o
Raul)
- Criei uma nova instância de Livro (o de Análise)
- Disse para a
instância de Livro que seu autor é o Raul;
- Gravei na base a instância de
Livro. Como o autor ainda não estava gravado, o db4o grava-o automaticamente
também.
- Repeti a operação com um novo autor e dois novos
livros
Percebam que a gravação foi muito simples. Nada de xml de
mapeamento, nada de atributos, nada de pilhas de camadas para fazer uma
simples gravação de dados.
Recuperando dados
O db4o tem 3 tipos de pesquisa possíveis:
* QBE (query
by example): recupera dados através de um objeto modelo. É a forma mais simples,
mas possui uma série de restrições
* SODA query: um estilo de query que até pouco tempo foi o mais
indicado para ser usado pelo db4o. Um ponto negativo é a utilização de
strings para identificar os campos na pesquisa o que não permite a checagem
de erros na compilação. O ponto positivo é a sua
velocidade de pesquisa
* Native Queries: lançadas recentemente no db4o, permitem uma
pesquisa de forma nativa orientada a objetos e checagem de tipos durante a
compilação.
Recuperando dados via QBE
Vamos criar uma pequena função de pesquisa de autor:
static Autor ProcuraAutor(string nome)
{
Autor proto = new Autor();
proto.Nome = nome;
ObjectSet result = objectBag.Get(proto);
if (result.HasNext())
return (Autor)result.Next();
else
throw new Exception(nome + " nao encontrado");
}
Em ordem, o que fiz:
- Criei um objeto Autor para
servir de template (proto)
- pesquisei no container atual o objeto proto
através de Get. O resultado será retornado em um ObjectSet
- Verifico se
existe algum objeto no ObjectSet com a função HasNext()
- Se existir um
objeto, retorno o mesmo através da função Next()
É importante salientar
que o ObjectSet não contem objetos instanciados automaticamente. Eles são apenas
instanciados quando forem explicitamente chamados,como no exemplo acima, com a
função Next(). O db4o chama isso de Ativação de Objetos e assim reduz-se a
quantidade de memória utilizada.
Recuperando dados via SODA
A pesquisa via SODA permite estabelecer critérios mais detalhados e também
permite ordenar o resultado. Essa pesquisa permite acessar diretamente os nós de
um graph de pesquisa:
static void LivrosDoAutor(Autor autor)
{
Query query = objectBag.Query();
query.Constrain(typeof(Livro));
query.Descend("_autor").Constrain(autor);
ObjectSet resultado = query.Execute();
if (resultado.Count > 0)
{
while (resultado.HasNext())
{
Console.WriteLine(resultado.Next());
}
}
else
{
Console.WriteLine("Não há nenhum livro do autor {0} cadastrado", autor.Nome);
}
}
Em ordem, o que fiz:
- Criei uma nova Query
-
Estabeleci como critério apenas os objetos do tipo livro;
- Dentro dos livros
quero que sejam listados apenas os objetos cujo campo "_autor" seja igual ao
objeto Autor passado como parâmetro. Aqui está o probleminha que citei mais
acima. Se alterarmos o nome do campo na classe, temos que tomar cuidado de
alterar o nome nas pesquisas também.
- Mandei rodar a query através de
query.Execute()
- Mostra todos os resultados da query na tela.
Se você
quiser ordernar os livros em ordem descendente, poderia acrescentar (antes da
linha ObjectSet resultado = query.Execute(); ):
query.Descend("_titulo").OrderDescending();
Recuperando dados via Native Queries
Acredito que vocês acharão esse modo o melhor de todos, pois aqui você usa a
própria linguagem de desenvolvimento para montar suas pesquisas!
Os
exemplos utilizarão Generics, mas você também pode fazer as pesquisas no
framework 1.1 (vou dar um exemplo mais abaixo)
Vamos criar uma nova
versão do exemplo de pesquisa via SODA, agora usando native queries:
static void LivrosDoAutorNQ(Autor autor)
{
IList livros = objectBag.Query(delegate(Livro candidato)
{
bool podeAdicionar = candidato.Autor == autor;
return podeAdicionar;
});
foreach (Livro livro in livros)
{
Console.WriteLine(livro);
}
}
Para fins didáticos fui um tanto quanto prolixo.
Em ordem, o
que eu fiz:
- Em uma IList<Livro> (uma lista só de livros) coloquei
o conteúdo da Query tipada. Cada elemento Livro da base é verificado pelo
delegate. Se atender a condição, ele é adicionado à lista.
- Faço um foreach
nos resultados e mostro o resultado na tela
No caso do Framework 1.1
teremos um pouco mais de trabalho pois não temos nele métodos anônimos. Teremos
que criar uma classe de pesquisa herdando de com.db4o.query.Predicate.
public class PesquisaLivros : Predicate
{
private Autor _autor;
public PesquisaLivros(Autor autor)
{
_autor = autor;
}
public Boolean Match(Livro livro)
{
return (livro.Autor == _autor);
}
}
usando: static void LivrosDoAutorNQFramework11(Autor autor)
{
System.Collections.IList livros = objectBag.Query(new PesquisaLivros(autor));
foreach (Livro livro in livros)
{
Console.WriteLine(livro);
}
}
Um pouco mais trabalhoso, não? Mais um motivo para você migrar
urgentemente para a versão 2.0 do .Net ;-)
Um outro exemplo: se você quiser pegar todos os objetos do tipo Livro na
base:
static void Catalogo()
{
foreach (Livro livro in objectBag.Query(typeof(Livro)))
{
Console.WriteLine(livro);
}
}
E no próximo capítulo...
Meu objetivo nessa primeira parte foi só introduzir o assunto.
Creio que muitos nunca ouviram falar em db4o portanto preferi mostrar apenas as
operações básicas. Nos próximos artigos mostrarei mais alguns exemplos de
utilização.
Por enquanto sugiro que você puxe o instalador do db4o e faça
algumas brincadeiras. O instalador disponibiliza um tutorial muito detalhado de
todas as funções do db4o.
Até a próxima!
/**
* Exemplo de utilização do db4o.
* Criado por Cássio Rogério Eskelsen (eskelsen at gmail.com)
* 29/11/2005
* */
using System;
using System.IO;
using System.Collections.Generic;
using System.Text;
using com.db4o ;
using com.db4o.query;
namespace db4oParte1
{
class Program
{
static ObjectContainer objectBag;
static void Main(string[] args)
{
// Para fins de teste, sempre uma base limpa
FileInfo fi = new FileInfo("arquivo.yap");
fi.Delete();
// "conecta" com o banco
objectBag = Db4o.OpenFile("arquivo.yap");
// cria massa de testes
CriaDados();
Autor fabio = ProcuraAutor("Fabio Camara");
Console.WriteLine("-------------------------------------------------");
Console.WriteLine("Autor: "+fabio);
Console.WriteLine("----------------LIVROS DO AUTOR------------------");
LivrosDoAutor(fabio);
Console.WriteLine("-------------------------------------------------\n");
Autor raul = ProcuraAutor("Raul Wazlawick");
Console.WriteLine("Autor: " + raul);
Console.WriteLine("-----LIVROS DO AUTOR (usando Native Queries)-----");
LivrosDoAutorNQ(raul);
Console.WriteLine("-------------------------------------------------\n");
Console.WriteLine("-----------------Catálogo completo---------------\n");
Catalogo();
Console.Read();
objectBag.Close();
}
static void CriaDados()
{
Autor raul = new Autor();
raul.Nome = "Raul Wazlawick";
raul.Email = "raul@acme.com";
Livro analise = new Livro();
analise.Autor = raul;
analise.ISBN = "8535215646";
analise.Titulo = "Análise e Projetos de Sistemas de Informação Orientados a Objetos";
objectBag.Set(analise);
Autor fabio = new Autor();
fabio.Nome = "Fabio Camara";
fabio.Email = "fabio@acme.com";
Livro dominando = new Livro();
dominando.Autor = fabio;
dominando.Titulo = "Dominando o Visual Studio.Net com C#";
dominando.ISBN = "8575021095";
objectBag.Set(dominando);
Livro cinquentaEOito = new Livro();
cinquentaEOito.Autor = fabio;
cinquentaEOito.Titulo = "58+ Soluções em .Net";
cinquentaEOito.ISBN = "8575021583";
objectBag.Set(cinquentaEOito);
}
static Autor ProcuraAutor(string nome)
{
Autor proto = new Autor();
proto.Nome = nome;
ObjectSet resultado = objectBag.Get(proto);
if (resultado.HasNext())
return (Autor)resultado.Next();
else
throw new Exception(nome + " nao encontrado");
}
static void LivrosDoAutor(Autor autor)
{
Query query = objectBag.Query();
query.Constrain(typeof(Livro));
query.Descend("_autor").Constrain(autor);
ObjectSet resultado = query.Execute();
if (resultado.Count> 0)
{
while (resultado.HasNext())
{
Console.WriteLine(resultado.Next());
}
}
else
{
Console.WriteLine("Não há nenhum livro do autor {0} cadastrado", autor.Nome);
}
}
static void LivrosDoAutorNQ(Autor autor)
{
IList livros = objectBag.Query(delegate(Livro candidato)
{
bool podeAdicionar = candidato.Autor == autor;
return podeAdicionar;
});
foreach (Livro livro in livros)
{
Console.WriteLine(livro);
}
}
static void LivrosDoAutorNQFramework11(Autor autor)
{
System.Collections.IList livros = objectBag.Query(new PesquisaLivros(autor));
foreach (Livro livro in livros)
{
Console.WriteLine(livro);
}
}
static void Catalogo()
{
foreach (Livro livro in objectBag.Query(typeof(Livro)))
{
Console.WriteLine(livro);
}
}
}
public class PesquisaLivros : Predicate
{
private Autor _autor;
public PesquisaLivros(Autor autor)
{
_autor = autor;
}
public Boolean Match(Livro livro)
{
return (livro.Autor == _autor);
}
}
public class Autor
{
private string _nome;
private string _email;
public string Nome
{
get { return _nome; }
set { _nome = value; }
}
public string Email
{
get { return _email; }
set { _email = value; }
}
public override string ToString()
{
return this.Nome+"("+this.Email+")";
}
}
public class Livro
{
private Autor _autor;
private string _titulo;
private string _isbn;
public string ISBN
{
get { return _isbn; }
set { _isbn = value; }
}
public string Titulo
{
get { return _titulo; }
set { _titulo = value; }
}
public Autor Autor
{
get { return _autor; }
set { _autor = value; }
}
public override string ToString()
{
return string.Format("Titulo: {0}\nAutor: {1}\nISBN: {2}\n\n", this.Titulo, this.Autor.Nome, this.ISBN);
}
}
}
Cassio R. Eskelsen - Desenvolvedor C# desde 2001. Atualmente trabalha como desenvolvedor independente de soluções na área de CRM e mantém um site relacionado ao projeto Mono e a Linguagem Boo: http://www.br-mono.org.
