Terça-feira, Abril 01, 2008Sistema de Notícias "Digg like" desenvolvido com db4o

Pessoal.Estou disponibilizando agora a projeto final de graduação

desenvolvido pelo aluno Cléverton Silva, sob minha orientação, no curso de Ciência da Computação na Universidade Federal do Espírito

Santo.

Trata-se de um sistema de notícias no estilo "Digg", com uma espécia de rankeamento automatico das notícias, baseado em filtragem

colaborativa.

O projeto foi desenvolvido utilizando as tecnologias .NET 2.0 e db4o.

Postado por dux2 às 1:28 AM 1 comentários

Marcadores: digg db4o .net2.0

Sexta-feira, Abril 13, 2007Especificações do DB4O

Especificações sobre o DB4O que podem ser encontradas na documentação

Postado por QuintaFeira às 2:15 PM 1 comentários

Marcadores: Especificações

Quinta-feira, Abril 12, 2007Native Queries

DB4O - Data Base For Objects

Native Queries – Parte 1 (por Jeudí Prando)

Antes de iniciar o artigo irei definir uma classe para servir de exemplo nos tópicos que serão apresentados.

public class Pessoa{

private string _nome;private string _sobreNome;

private string _sexo;

public Pessoa(){

this._nome = “”;this._sobreNome = “”;

this._sexo = “”;}

public Pessoa(string nome, string sobreNome, string sexo)

{this._nome = nome;

this._sobreNome = sobreNome;this._sexo = sexo;

}

public string Nome{

get{ return this._nome; }

set{ this._nome = value; }}

public string SobreNome{

get{ return this._sobreNome; }set{ this._sobreNome = value; }

}

public string Sexo{

get{ return this._sexo; }set{ this._sexo = value; }

}}

Pronto agora que a nossa classe modelo esta definida vamos ao que interessa.

DB4O nos fornece três tipos de pesquisa

• Query-By-Example (QBE)• SODA API.

• Native Queries (NQ)

Como neste artigo o meu foco é o Native Querie não falarei sobre os outros tipos de pesquisa

O tipo de pesquisa Native Queries (NQ) é o sistema de pesquisa principal do DB4O, recomendada para o uso geral.

Não seria agradável se pudesse realizar pesquisas utilizando as regras da linguagem de programação que você esta utilizando?

Não seria agradável se todas as suas pesquisas fossem fortemente tipadas?

Não seria agradável se você pudesse utilizar todo o poder da Linguagem Orientada a Objeto para realizar as suas pesquisas?

Utilize Native Queries(NQ)!

Native Queries é a principal sistema de pesquisa do DB4O e é o sistema de pesquisa recomendado para utilizar em sua aplicação.

As pesquisas em Native Querie utilizam a semântica da linguagem de programação que você esta utilizando, é uma escolha segura para o

futuro.Native Queries (NQ) é fortemente tipado.

Native Queries estão disponíveis para todas as plataformas suportadas por DB4O.

Native Querie fornecem a habilidade de executar uma ou mais linhas de código de encontro a todos as instancias de um objeto em um

repositório de objetosAs expressões de Native Queries devem retornar verdadeiro para

recuperar os objetos que esta sendo testado pela expressão.DB4O tentará otimizar as expressões de Native Queries e executá-la de encontro aos índices e a busca é otimizada de forma a instanciar

de verdadesomente os objetos que irão fazer parte da lista.

Essas expressões são exatamente as mesmas que você utiliza em um "if", por exemplo, se retornar verdadeiro o objeto é adicionado a lista

se retornarfalso o objeto não é adicionado a lista.

Um exemplo de Expressões de Native Queries:

IList iLista = db.Query(delegate(Pessoa pessoa)

{return

(pessoa.Nome.Contains("a"));});

Esta é a expressão da nossa Native Querie utilizada neste exemplo:

delegate(Pessoa pessoa)

{return

(pessoa.Nome.Contains("a"));}

Esta expressão juntamente com o metodo Query, esta dizendo que é para percorrer todos os objetos do tipo Pessoa "delegate(Pessoa

pessoa)" dentro do nosso repositório de objetos.

A cada objeto percorrido será instanciado no atributo pessoa dentro do delegate"delegate(Pessoa "pessoa")", e será testado conforme o

código que vem da sua própria linguagem de programação,no nosso caso, procura por pessoas que contenham a letra "a" no

nome "pessoa.Nome.Contains("a")", se o objeto pessoa atualmente instanciado em "pessoa" tiver a letra "a" no nome a expressão

retornará verdadeiro, fazendo com que o atual objeto pessoa faça parte da lista que será montada ao termino do percorrer e validar

todos os objetos do nosso repositório de objetos, no nossocaso os objetos do tipo pessoa, gerando assim o nosso famoso

"Result Set".

vamos ver alguns exemplos, utilizando nossa classe modelo:

/// vamos instanciar algumas pessoas

Pessoa fulano = new Pessoa();fulano.Nome = "Fulano";

fulano.Sexo = "M";

Pessoa beltrano = new Pessoa("Beltrano","","M");

Pessoa ciclana = new Pessoa("Ciclana","","F");

/// vamos iniciar a comunicação

com o nosso repositório de objetos

IObjectContainer db = Db4oFactory.OpenFile("dados.yap")

;

/// persistindo as pessoas instanciadas

db.set(fulano);db.set(beltrano);db.set(ciclana);

agora vamos recuperar todas as pessoas do sexo Feminino, utilizado Native Querie

IList lista = db.Query(delegate(Pessoa pessoa){

return pessoa.Sexo = "F"});

neste caso seria retornado somente o objeto Pessoa "ciclana"

se eu quisesse utilizar o poder que se tem de uma linguagem orientada a objeto poderíamos fazer um Método que busque

todas as pessoas de um sexo especificado. Ex:

public List RecuperarListaPessoaDeterminadoSe

xo(string sexo){

/// vamos iniciar a comunicação

com o nosso repositório de objetos

IObjectContainer db = Db4oFactory.OpenFile("dados.yap")

;

/// vamos recuperar as pessoas de um sexo especificado através do

parâmetro "sexo"return new

List(db.Query(delegate(Pessoa pessoa){ return pessoa.Sexo =

sexo}));}

agora ao executar o método

RecuperarListaPessoasDeterminadoSexo("M");

seria retornado uma lista contendo os objetos Pessoas: Fulano e Beltrano

poderíamos estender este artigo realizando muitas variações de consulta utilizando Native Queries, mas esta variação

é devida a liberdade que a linguagem orientada a objeto te dá...

Por exemplo poderíamos utilizar a ordenação no List, buscar pessoas que iniciem ou não contenham sobre nome e assim

por diante...

Mas o meu objetivo neste artigo é passar um pouco de noção do que é Native Querie, como Utilizar, como montar expressões,

como o mesmo funciona e não falar sobre orientação a objeto apesar do assunto esta contido em Native Queries

espero ter ajudado alguém! rss

Boa Sorte!

Postado por QuintaFeira às 5:01 PM 1 comentários

Marcadores: Native Queries

Sexta-feira, Novembro 24, 2006Simples, mas prático

Galera, vou postar um exemplo bem simples de como realizardois tipo diferentes de busca aproximada utilizando metodos

nativos do DB4o, sem precisar fazer nada de novo.

Nossa classe de dominio:

public class Regra {private String padrao;

private String tratamento;private String modulo;

public String getModulo() {return modulo;

}public void setModulo(String

modulo) {this.modulo = modulo;

}public String getPadrao() {

return padrao;}

public void setPadrao(String padrao) {

this.padrao = padrao;}

public String getTratamento() {return tratamento;

}public void setTratamento(String

tratamento) {this.tratamento = tratamento;

}}

Parte 2: DAO

Nossa classe DAO:

import com.db4o.Db4o;import com.db4o.ObjectContainer;

import com.db4o.ObjectSet;import com.db4o.query.Constraint;

import com.db4o.query.Query;

import dominio.Palavra;import dominio.Regra;

public class DAORegra {

public ObjectContainer db;

public DAORegra(){

}

public void open(String idioma){this.db =

Db4o.openFile("memoria/regras/"+idioma+".regras");

}

public void close(){this.db.close();

}

public void store(String padrao, String tratamento,String modulo){

Regra regra = new Regra();

if(!padrao.equalsIgnoreCase("") && !

tratamento.equalsIgnoreCase("")){

regra.setPadrao(padrao.toUpperCase());

ObjectSet result = db.get(regra);

if(result.size() != 0){

regra = (Regra) result.next();}

regra.setModulo(modulo);regra.setPadrao(padrao.toUpperCas

e());regra.setTratamento(tratamento.to

UpperCase());db.set(regra);db.commit();

}

}

public String[] getRegras(String padrao, String tratamento,String

modulo){Regra regra = new Regra();

Query query=db.query();query.constrain(Regra.class);

Constraint constrPadrao=null,constrModulo=nu

ll,constrTratamento=null;

constrPadrao=query.descend("modulo").constrain(modulo);

if(!padrao.equalsIgnoreCase("")){constrPadrao=query.descend("padrao").constrain(padrao.toUpperCase(

)).startsWith(true);}

if(!tratamento.equalsIgnoreCase("")){constrPadrao=query.descend("tratamento").constrain(tratamento.toUp

perCase()).startsWith(true);}

ObjectSet result = query.execute();

String[] regras = new String[result.size()];

if(result.size() == 0){regras = new String[1];

regras[0] = "Nao Encontrada nenhuma ocorrência";

}else{

for(int i=0;iregra = (Regra) result.next();

regras[i] = regra.getPadrao()+" : "+regra.getTratamento();

}}

return regras;}

public void delete(String padrao, String tratamento,String modulo){

Regra regra = new Regra();regra.setModulo(modulo);

if(!padrao.equalsIgnoreCase("") && !

tratamento.equalsIgnoreCase("")){

regra.setPadrao(padrao.toUpperCase());

regra.setTratamento(tratamento.toUpperCase());

ObjectSet result = db.get(regra);

if(result.size() != 0){regra = (Regra) result.next();

db.delete(regra);db.commit();

}}

}

public Regra existeRegraIgual(String padrao){

Regra regra = new Regra();

Query query=db.query();query.constrain(Regra.class);

Constraint constr=null;constr=query.descend("padrao").co

nstrain(padrao);

ObjectSet result = query.execute();

regra = (Regra) result.next();

return regra;}

public int existeRegra(String padrao){

Regra regra = new Regra();

Query query=db.query();query.constrain(Regra.class);

Constraint constr=null;constr=query.descend("padrao").constrain(padrao.toUpperCase()).sta

rtsWith(true);

ObjectSet result = query.execute();

return result.size();}}

Utilizando isso:(frame.getPalavras() retorna palavras é um vetor Palavra[],

presumam isso):

public class aplicarRegras {

public aplicarRegras(frameGeral frame){

Palavra palavraAtual;Regra regraAtual;

Palavra[] palavras =

frame.getPalavras();String bufferGlobal="",regra="",

pilha="", candidataRegra="", idioma=frame.getIdiomaDeEntrada()

;DAORegra daoRegras = new

DAORegra();daoRegras.open(idioma);

int i = 0;while(i<PALAVRAS.LENGTH){

palavraAtual = palavras[i];if(regra.equals(""))

candidataRegra = palavraAtual.getClasseGramatical(

);else

candidataRegra = regra+" "+palavraAtual.getClasseGramatica

l();if((!

palavraAtual.getClasseGramatical().equalsIgnoreCase("Nao

Encontrada"))&&(daoRegras.existeRegra(candidat

aRegra)>0)){regra = candidataRegra;if(pilha.equals(""))

pilha = palavraAtual.getGrafia();else

pilha += " "+palavraAtual.getGrafia();

}else{

if(!pilha.equals("")){regraAtual =

daoRegras.existeRegraIgual(regra);

if(regraAtual != null){bufferGlobal+="<"+regraAtual.getM

odulo()+">"+pilha+"";}else{

bufferGlobal+=pilha+" ";}}

bufferGlobal+=palavraAtual.getGrafia()+" ";pilha="";regra="";

}i++;}

daoRegras.close();frame.setTextoMarcado(bufferGloba

l);}

}

Postado por Marcello Novaes às 8:53 PM 0 comentários

Sexta-feira, Novembro 17, 2006Erros Comuns - Parte 1

Neste meu primeiro post venho trazer a tona erros mais comuns entre usuários iniciantes. Nesta minha primeira semana de uso

detectei alguns erros cumuns de desenvolvimento que cometi e me fez perder certo tempo, e como percibi que são normais de se

cometer quando se aprende a usar uma nova tecnologia pretendo passar este conhecimento a usuários iniciantes para que estes

ganhem tempo !!!

Chamei de Erros mais Comuns - Parte 1 devido a minha pouca experiência neste momento e a poucas possíbilidades exploradaas ainda sobre o uso do db4o. Em breve acredito cometer novos erros

que possam ser digno de um segundo post, e para no futuro condençar num artigo mais completo e bem escrito.

Construtor não Vazio x Pesquisa FullObjects:

Chamo aqui de pesquisa FullObjects aquela que retorna todos os elementos de uma classe que se encontra armazenadas no db4o.

(pode-se fazer uma analogia próxima ao Select * from Tabela )

Para se buscar todos os objetos da classe usando o método Get deve-se preencher todos os campos da classe com valores nulo.

Erro Comum: O construtor de uma classe pode preencher um conjunto de atributos com informações padrões.

Resultado deste Erro: O Db4o rretornará as informações somente dos objetos que não tiveram estes atributos alterados, deixando muitos

objetos de fora.

Correção Sugerida: O objeto deve possuir um Construtor (ou um método) que seta nullo em todos os atributos não constantes do

objeto.

Inserir x Alterar

Quando agente quer inserir um objeto, agente cria um objeto vazio, preenche as inforções e salva. Quando agente pretende alterar devemos buscar o objeto no banco, editar suas informações e

recoloca-lo no banco.

Erro Comum:

Quando agetne utilizava o SGBD relacional agente pegava o objeto que nos era passado por outra camada da aplicação, desmenbramos

em um comando SQL e executamos. Quando agente recebe este objeto da camada de controle (ou outra dependedo da arquitetura) a

ideia intuitiva é usar o metodo Set para salvar as alterações.

Resultado deste Erro: O objeto passado cria uma nova informação no db4o, em vez de alterar a existente como foi o desejado.

Correção Sugerida: Deve se usar o método Get para obter o objeto do banco que deseja se editar, alterar as informações que forem

necessárias e usar o método Set para salvá-lonovamente no Banco.

Conclusão:São algumas sugestões que possam facilitar a vida de quem está iniciando, porém muitas delas possuem melhores soluções, Deixo então o convite para todos os interessados em estudar este novo

paradigma que partipem do grupo db4oBrasil dando dicas e sugestões e efetuando críticas construtivistas.

Abraços a TodosBernard C. Pereira

Postado por Bernard Corrêa Pereira às 10:08 AM 3 comentários

Quinta-feira, Novembro 09, 2006Estamos no Imasters

Olá pessoal, a partir de hoje estamos representados no portal imasters. O primeiro artigo que mandei nada mais é do que as

informações fornecidadas no próprio site db4o resumidas. Espero receber sugestões de vocês para os próximos artigos.

[]'s

Postado por dux2 às 7:54 PM 3 comentários

Terça-feira, Outubro 31, 2006Popularizando o DB4O

O Eduardo (EddieStone) apresentou uma idéia que eu imediatamente gostei: "Vamos criar um curso para ensinar a utilizar o DB4O".

Ontem,em uma conversa com meu orientador do mestrado apresentamos a ideia, e o professor complementou com outra ideia interessante: "Vamos oferecer uma discipĺina optativa de Tópicos

Especiais em Banco de Dados abordando esse tema."

Bem, resumindo, provavelmente vamos no proximo semetre ter na Ufes uma disciplina onde poderemos apresentar o DB4O para os

alunos interessados.. eu particularmente fiquei muito animado com a idéia!!!

Tomara que o resultado disso seja que muitos alunos nossos utilizem o DB4O em seus projetos de graduação!!!!!!!!!!!!!!!!!!

Postado por Marcello Novaes às 9:46 PM 2 comentários