Como prometido, começaremos então nosso tutorial sobre DB4O. Nesta primeira parte, vamos falar um pouco mais sobre suas vantagens e desvantagens, as ferramentas que vamos utilizar e por fim, como criar e estabelescer conexões com o DB4O.

Perguntas

  • É um novo SGBD? De forma alguma! DB4O é uma Framework muito poderosa para manipulação de objetos como base de dados.

  • Como se manipula as entidades? Entidades não existem em DB4O. Na verdade, são tratadas como objetos. Em nosso caso, estamos trabalhando com C#, então podemos dizer que uma entidade/tabela é o escopo do objeto, ou seja, o definição da classe. Já as tuplas/linhas/registros de uma entidade/tabela, são os objetos em si.

  • O modelo de Query é o mesmo padrão SQL-ANSI? Muito pelo contrário! Não existem sql’s em DB4O. Você busca por seus objetos através de metodologias predefinidas. Chamamos estas metodologias de Native Query’s.

  • Como se conecta? DB4O mantém todos seus objetos em um arquivo com a extensão “.yap” (teste.yap). Para se conectar, basta abrir este arquivo, utilizando os métodos indicados pela Framework do DB4O. É possível fazer conexões nos padrões Direto, Client/Server e Client/Server Embutido.

Vantagens

  • Fácil maneira de se armazenar objetos nativamente em JAVA ou .NET (estão desenvolvendo uma versão para PHP também);
  • Melhor escolha para aplicações embarcadas (Transportes, Redes, Ciências Naturais, Indústrias, Softwares Para Usuário Final, Games);
  • Performance até 40x mais rápida que qualquer banco de dados relacional;
  • Processa até 200.000 objetos por segundo;
  • Código aberto;
  • Custo baixo (Praticamente ZERO);
  • Elimina a necessidade de um administrador de banco de dados (DBA).

Desvantagens

  • As versões atuais não possuem um gerenciador alto nível que atenda todas as necessidades de administração do banco de dados (arquivo “.yap”);
  • As versões mais antigas não haviam implementadas estruturas para transações (COMMIT, ROLLBACK).

Ferramentas

Linguagem C#

  • É a linguagem de referência da Microsoft;
  • Fácil de usar;
  • Gerenciamento de memória automático;
  • Tipagem forte dinâmica e estática;
  • Suporte à reflection, que informa os tipo em tempo de execução;
  • Suporte à ReferenceType e ValueType;
  • Boa performance.

Plataforma ASP.NET

  • O sistema pode ser distribuído sem a necessidade de instalação nas estações;
  • É compilado;
  • Não importa o sistema operacional para ser executado;
  • Diminui o tráfego na rede;
  • Ferramentas que facilitam várias operações.

Framework DB4O

  • Controla a conexão com o banco de dados e execução das Native Query’s;
  • Contém vários métodos de operações simples que ajudam o desenvolvedor. Conversões e verificações;
  • Estrutura de classes e métodos que permitem fazer as ligações entre os dados (objetos) - JOIN.

Comparação

Comparação - DBR x DBOO

Passo a Passo

  • Conexão (Direta, Client/Server ou Client-Server Embutido);
  • Manipulação dos Objetos (Inserir, Alterar, Excluir, Selecionar [ QBE, SODA, Native-Query's ]);
  • Tratamento personalizado;
  • Fim da Transação;
  • Fim da Conexão;

Mão na Massa - Conectando

Primeiro, é importante ter em mente que DB4O é uma Framework, para tanto, é necessário fazer o download das DLL’s no site da DB4O. Segue a lista de links úteis:

Depois que baixar as DLL’s, importe-as para seu projeto. Agora, vamos criar uma classe para gerenciar nossas conexões, para isto, vamos adicionar um Using padrão.

using Db4objects.Db4o;

Agora vamos fazer o esboço das classes de nosso namespace:

using Db4objects.Db4o;

namespace ConexaoDB4O
{
  public class Direta
  {

  }

  public class ClienteServidor
  {

  }

  public class ClienteServidorEmbutido
  {

  }
}

Conexão Direta

Única e exclusivamente criada para ser utilizada no desenvolvimento de aplicações embarcadas.

public class Direta
{
  private IObjectContainer _conn;
  private string _nomeBanco;

  public Direta(string nomeBanco)
  {
    this._nomeBanco = nomeBanco;
  }

  public IObjectContainer Conexao
  {
    get { return this._conn; }
  }

  public string NomeBanco
  {
    get { return this._nomeBanco; }
    set { this._nomeBanco = value; }
  }

  public Abrir()
  {
    this._conn = Db4oFactory.OpenFile(this._nomeBanco);
  }

  public Abrir(string nomeBanco)
  {
    this._conn = Db4oFactory.OpenFile(nomeBanco);
  }

  public Fechar()
  {
    this._conn.Close();
    this._conn = null;
  }
}

Conexão Cliente/Servidor

É a forma clássica de se conectar a um Servidor de SGBD, possui fácil acesso, bastando criar uma “aplicação” a mais no projeto, que será o seu “servidor”.

As operações Cliente/Servidor são todas feitas através dos “read commited”. Ao instanciar um novo ObjectContainer, todas as operações que forem feitas, na verdade, estarão na memória até que se execute o método Commit(), que atualizará o banco de dados.

Lembrem-se, o servidor deverá ter conhecimento das mesmas classes que a aplicação, na segunta parte do documento, trataremos isto.

public class ClienteServidor
{
  private IObjectContainer _connClient;
  private IObjectContainer _connServer;
  private string _nomeBanco;
  private int _porta;
  private string _host;

  public ClienteServidor(string nomeBanco, string host, int porta)
  {
    this._nomeBanco = nomeBanco;
    this._host = _host;
    this._porta = porta;
  }

  public IObjectContainer ConexaoServidor
  {
    get { return this._connServer; }
  }

  public IObjectContainer ConexaoCliente
  {
    get { return this._connClient; }
  }

  public string NomeBanco
  {
    get { return this._nomeBanco; }
    set { this._nomeBanco = value; }
  }

  public string Host
  {
    get { return this._host; }
    set { this._host = value; }
  }

  public int Porta
  {
    get { return this._porta; }
    set { this._porta= value; }
  }

  public AbrirServidor()
  {
    this._connServer = Db4oFactory.OpenServer(this._nomeBanco, this._porta);
  }

  public void AddUsuarioServidor(string usuario, string senha)
  {
    if (this._connServer != null)
      this._connServer.GrantAccess(usuario, senha);
    else
      throw new Exception("Servidor não inicializado!");
  }

  public FecharServidor()
  {
    this._connServer.Close();
    this._connServer = null;
  }

  public AbrirCliente(string usuario, string senha)
  {
    try
    {
      this._connClient = Db4oFactory.OpenClient(this._host, this._porta, usuario, senha);
    }
    catch(Exception ex)
    {
      throw new Exception("Usuário e/ou Senha inválidos!");
    }
  }

  public FecharCliente()
  {
    this._connClient.Close();
    this._connClient = null;
  }
}

Conexão Cliente/Servidor Embutido

Elimina a necessidade de se ter um servidor “externo”. É possível instanciar um servidor na mesma máquina da aplicação, o que torna extremamente recomendado (é o que mais gosto) para o desenvolvimento de aplicações WEB.

public class ClienteServidorEmbutido
{
  private IObjectContainer _connClient;
  private IObjectContainer _connServer;
  private string _nomeBanco;

  public ClienteServidor(string nomeBanco)
  {
    this._nomeBanco = nomeBanco;
  }

  public IObjectContainer ConexaoServidor
  {
    get { return this._connServer; }
  }

  public IObjectContainer ConexaoCliente
  {
    get { return this._connClient; }
  }

  public string NomeBanco
  {
    get { return this._nomeBanco; }
    set { this._nomeBanco = value; }
  }

  public AbrirServidorEmbutido()
  {
    this._connServer = Db4oFactory.OpenServer(this._nomeBanco, 0);
  }

  public FecharServidorEmbutido()
  {
    this._connServer.Close();
    this._connServer = null;
  }

  public AbrirCliente()
  {
    try
    {
      this._connClient = this._connServer.OpenClient();
    }
    catch(Exception ex)
    {
      throw new Exception("Usuário e/ou Senha inválidos!");
    }
  }

  public FecharCliente()
  {
    this._connClient.Close();
    this._connClient = null;
  }
}

Então, por enquanto é só pessoal. Até o Tutorial de DB4O - Parte II.