Muy Breve Resumen de DB4O Para Java

-Base de Datos Orientadas a Objetos-

Juan B. Cabral
UTN - FRC - TSB
V. 1.0.1b - 2009/10/13

Introducción.

DB4O es un novedoso motor de base de datos orientada a objetos. Sus siglas se corresponden
con la expresión "DataBase 4 (for) Objects", que a su vez es el nombre de la compañía
que lo desarrolla: db4objects, Inc.
Las claves innovadoras de este producto es su alto rendimiento (sobre todo en modo
embebido) y el modelo de desarrollo que proporciona a las aplicaciones para su capa de
acceso a datos, el cual propugna un abandono completo del paradigma relacional de las
bases de datos tradicionales.
De este modo, tenemos las siguientes consecuencias directas resultantes de este nuevo
paradigma:
● Deja de existir un lenguaje SQL de consultas/modificaciones para pasar a crearse
sistemas de consulta por métodos delegados y actualización/creación/borrado
automático de entidades mediante código compilable.
● Se elimina la necesidad de representar el modelo de datos de la aplicación en dos
tipos de esquemas: modelo de objetos y modelo relacional. Ahora el esquema de
datos del dominio viene representado por la implementación que se realice del
diagrama de clases.
● Se consigue evitar el problema del Object-Relational Impedance Mismatch sin
sacrificar el rendimiento que los mapeadores objeto-relacionales sufren
actualmente para llevar a cabo el mismo objetivo.
La mayor clave del éxito que está teniendo este motor de base de datos frente a otros
competidores que han desarrollado tecnologías similares, es que se ha optado por un
modelo de licenciamiento idéntico al utilizado por empresas como MySQL: licencia dual
GPL/comercial. Es decir, si se quiere desarrollar software libre con esta librería, su uso no
conlleva ningún coste por licencia; sin embargo si se desea aplicar a un software
privativo, se aplica otro modelo de licenciamiento concreto.
Actualmente este producto funciona como una librería para dos tipos de plataformas de
desarrollo: Java y.NET (tanto la implementación de Microsoft como la de Mono).

Fuente: Wikipedia
Link: http://es.wikipedia.org/wiki/Db4o

Caracteristicas.
● DB orientada a objetos 100%.
● Puede mapearse relacionalmente.
 ● Licencia GPL para proyectos libres.
● Licencia Comercial para proyectos comerciales.
● ACID Test.
● Disponible para java y .net/mono.

Modelo de Datos a Utilizar.

Persistir.

● Todas las operaciones sobre la base de datos se hace a través de una instancia de
"ObjectContainer".
● Se obtiene de la siguiente manera.

ObjectContainer oc = Db4o.openFile(<PATH A UN ARCHIVO>);

● Para persistir un objeto se utiliza el metodo "store(obj)" de "ObjectContainer".

Auto fiat = new Auto("Fiat", 123);

Persona tito = new Persona("tito", "peru 123 pb", fiat);
oc.store(fiat); // Persistimos el auto
oc.store(tito); // Persistimos la persona

● Hay que tener cuidado que si un objeto contiene a otro (en este caso tito conoce a fiat)
es importante primero guardar el contenido y luego el contenedor (primero el auto y
después la persona); ya que sino al guardar tito tito guardara automáticamente su propia
instancia de auto diferente a la que esta en fiat.

Como guarda Db4o los Datos.

 ● Todos los objetos internamente se guardan con un identificador numérico único (similar a
un PK de una base de datos relacional) pero no existe dentro de las instancias de
nuestros objetos.
● Para acceder a las propiedades internas de db4o esta disponible un objeto
"ExtObjectContainer".
● Ejemplo de acceso a los datos internos a db4o:

ExtObjectContainer eoc = oc.ext(); // obtenemos el extobject container

long fiatID = eoc.getID(fiat); // obtenemos el id unico de esta instancia de
// fiat
fiat = eoc.getByID(fiatID); // obtenemos la misma instancia de fiat con su id

● Existen otras propiedades que se puede acceder con ExtObjectContainer.

Recuperando Datos.

● Db4o nos brinda 3 mecanismos para acceder a los datos almacenados:

○ QbE - Query By Example.
○ SODA - Simple Object Data Acces
○ NQ - Native Queries.
● En todos los casos db4o siempre nos devuelve una instancia de "ObjectSet" iterable y
genérico al objeto buscado.

Query by Example.

● Es el mecanismo mas sencillo, consiste en crear una instancia con los datos que uno
quiere buscar y dejando sus valores por defecto en los que no les interesa el valor que
contenga.
● Ejemplo:

Persona filtro = new Persona(null, null, fiat); //las personas que poseean
// esa instancia de auto.
filtro = new Persona("tito", null, null); // las personas que se llamen
"tito"
ObjectSet<Persona> os = oc.queryByExample(filtro); //realizamos la query
while(os.hasNext()){ // mientras hayan resultados
Persona p = os.next(); // extraemos la siguiente persona
System.out.println(p); // imprimimos la persona por parametro
}

● Como se evidencia QbE tiene muchisimas limitaciones:

○ No se podrían hacer búsquedas del tipo "todos los nombres que empiezan por "ti";
○ No podemos buscar ocurrencias de valores por defecto, como por ejemplo todas las
personas que no posean autos sin importar su nombre y su dirección; ya que la
siguiente consulta traería todas las personas con y sin auto.

filtro = new Persona(null, null, null); // null es valor por defecto

○ Existen otras desventajas pero estas dos evidencian los problemas principales de
QbE.

SODA.
 ● Es el mas complejo de los mecanismos.
● Es de bajo nivel.
● Es útil para situaciones donde QbE es muy estricto.
● Solo esta disponible por motivos de retrocompatibilidad.
● No sera abordado y puede consultarse el manual de referencia de db4O para mas
información.

Native Queries.

● Es el "estándar" de búsquedas en bases de datos

orientadas a objetos.
● Se prefiere sobre Soda y QbE.
● Existen papers proponiendolos.
● consiste en crear un nuevo objeto en el lenguaje nativo de la aplicación que represente la
busqueda.
● En el caso de java implica un objeto que extienda de la clase abstracta "Predicate" y
redefina su unico método "match(obj)"
● db4o compara todos los objetos de un tipo dado con "match(obj)" y si este devuelve
"true" se incluirá el objeto en el resultado.
● Ejemplo:

Class BuscadorDeNombres<Persona> extends Predicate{ //el genérico del tipo a

// buscar
@Override
public boolean match(Persona p) { // recibe por parámetro un objeto a
buscar
return p.getName.startsWith("ti"); // si el nombre de p empieza por
"ti"
}
}

ObjectSet<Persona> os = oc.query(new BuscadorDeNombres()}; // se realiza la

// búsqueda

o como clase anónima (lo ideal):

ObjectSet<Persona> os = oc.query(
new Predicate<Persona>(){
@Override
public boolean match(Persona p) {
return p.getName.startsWith("ti");
}
});

Update.
● Solo consiste en obtener un objeto ya almacenado, modificarlo y volverlo a guardar.
● ejemplo:

ObjectSet<Persona> os = oc.query(
new Predicate<Persona>(){
@Override
public boolean match(Persona p) {
 return p.getName.startsWith("ti");
}
});
Persona primero = os.get(0); // obtenemos la primer persona del resultado
primero.setName("toto"); // cambiamos el nombre
oc.store(primero);

Delete.
● Solo consiste en obtener un objeto ya almacenado, y borrarlo con el método
"delete(obj)" del ObjectContainer.
● ejemplo:

ObjectSet<Persona> os = oc.query(
new Predicate<Persona>(){
@Override
public boolean match(Persona p) {
return p.getName.startsWith("ti");
}
});
Persona primero = os.get(0); // obtenemos la primer persona del resultado
oc.delete(primero); // se borra primero

Transacciones.

● El "ObjectContainer" posee dos comandos:

○ comit()
○ rollback()

Commit.

● Es homólogo a las RDBMS, confirma todos los cambios hasta el momento como
permanentes en la base de datos.
● El metodo "close()" de "ObjectContainer" tambien es un commit.

Rollback.

● vuelve los cambios hasta el ultimo commit

● luego de hacer un rollback, es necesario actualizar los objetos que estan activos
● Un objeto activo es aquel que esta referenciado en memoria aplicación en un momento
dado. Esto se realiza con el método "refresh(obj, int)" de "ExtObjectContainer"

Ejemplo:

ObjectSet<Persona> os = oc.query(
new Predicate<Persona>(){
 @Override
public boolean match(Persona p) {
return p.getName.startsWith("ti");
}
});
Persona primero = os.get(0);
primero.setName("toto");
oc.store(primero);
oc.commit(); // confirmamos el cambio de nombre
primero.setName("Paco buen gesto"); //volvemos a cambiar el nombre
oc.store(primero);
oc.rollback(); // volvemos a dejar el nombre como "toto"
// cabe aclarar que en este momento primero (que esta en memoria)
// aun mantiene el nombre "Paco buen gesto" y hay que
// actualizarlo.
db.ext().refresh(primero, Integer.MAX_VALUE); //max value indica que sea al
// ultimo commit de su historial
primero.setName("Amilcar Soncillo"); // cambiamos el nombre una vez mas
oc.close(); // se confirma Amilcar Soncillo como nombre

Profundidad.
● Cuando se hacen búsquedas y actualizaciones puede que los resultados vengan en null.
Como cuando se almacena una coleccion(ArrayList, LinkedList, Hash...) en un objeto.
● Esto se debe al nivel de profundidad en la activación (instanciación interna en el árbol de
objetos) que hace db4o al sacar un objeto de la base para optimizar recursos.
● En el caso de las colecciones es que heredan de muchos tipos e implementan bastantes
interfaces por lo que el árbol de objetos se vuelve más profundo de lo esperado y el nivel
de activación de db4o por omisión (que es de 5 niveles) no cubre a esos nodos, por lo
que hay que configurar la base para que active a esos nodos al momento de realizar una
consulta. Esta configuración se realiza de la siguiente forma:

Db4oFactory.Configure().ObjectClass(TuTipodeObjeto.Class).UpdateDepth(20);
Db4oFactory.Configure().ObjectClass(TuTipodeObjeto.Class).CascadeOnActivate(tru
e);
Db4oFactory.Configure().ObjectClass(TuTipodeObjeto.Class).CascadeOnUpdate(true)
;
Db4oFactory.Configure().ObjectClass(TuTipodeObjeto.Class).CascadeOnDelete(true)
;

● Hay que realizar esto ANTES de abrir el ObjectContainer.

Recursos, Artículos Recomendados y Fuentes Bibliográficas.

● Db4O Homepage:
○ http://www.db4o.com/
● Db4O Downloads:
○ http://www.db4o.com/DownloadNow.aspx
● Db4O - Formula One Tutorial:
○ http://developer.db4o.com/Resources/view.aspx/Formula_One_Tutorial
● Db4O FAQ:
○ http://developer.db4o.com/ProjectSpaces/view.aspx/Espanol/FAQ