Db4o

Muchas veces cuando se presenta un artculo tan tcnico, se lo orienta hacia un pblico
especializado o avanzado, y el enfoque es mostrar los ltimos detalles del producto de
turno, sin embargo si hicieramos esto aqu dejaramos afuera a los lectores que
descubren db4o. Tal vez no entenderan cundo ser viable su uso o bien qu es
realmente lo grandioso de db4o. En cambio si el enfoque fuera arranquemos desde
cero, los desarrolladores avanzados, o incluso intermedios, se aburriran y dejaran de
lado el artculo buscando las ltimas novedades. Por ello les recomiendamos a quienes
estn avanzados, que en el caso de no responder a sus dudas, consulten hacia el final de
este artculo en donde se encuentran las direcciones URL de recursos, entre ellos los de
la gran comunidad de usuarios de db4o, donde pueden realizar consultas especficas.
Tanto si usted ha tenido alguna experiencia con bases de objetos (ODBMS), los
conocidos como mapeadores objetos-relacionales (ORDBMS), es de la vieja guardia
de las bases relacionales (RDBMS), como si jams ha tenido experiencia persistiendo
informacin y quiere averiguar si db4o es para usted, creemos que este artculo puede
serle de ayuda.
Qu no encontrar aqu
La eleccin de un esquema de persistencia, an cuando debera ser tcnicamente una de
las cuestiones menos polmicas debido a la enorme cantidad de documentacin y
comparativas realizadas y disponibles pblicamente, ha sido desde hace unos aos
objeto de mltiples controversias. Sin embargo, el objetivo de este artculo no est
centrado en los aspectos netamente comparativos, ni en convencer al lector de
abandonar su preferencia por las bases relacionales o herramientas de mapeo, tareas que
de por s requeriran de un artculo aparte y cierta disposicin especial al cambio. La
idea aqu es presentar un vistazo a las caractersticas fundamentales de db4o, dejando a
los lectores la posibilidad de generar nuevas entregas, ahondando en cuestiones que
consideren de su inters.
Introduccin
Vamos a ver entonces algunas caractersticas claves de db4o, la base de objetos nativa de
alto rendimiento para .Net y Java. A continuacin mostraremos cmo instalar y
comenzar a utilizar este motor de persistencia. Y seguidamente incluiremos cmo
resolver algunas tareas simples en C# (muy fcilmente adaptables a Java), una pequea
conclusin y daremos fuentes para ms informacin.
A grandes rasgos, las caractersticas fundamentales de db4o son:
- Alto rendimiento: Ofreciendo notables ventajas con sistemas que utilizan
objetos anidados o compuestos, o en donde existen referencias cruzadas,
herencia o interacciones ricas entre los objetos.
- Por su bajo consumo de recursos, (de 600Kb a 800Kb de footprint) es
especialmente apta para dispositivos mviles y entornos Clientes/Servidor,
aunque no necesariamente limitada slo a ellos.
- Doble licencia: GPL (Open Source) y Comercial (que incluye soporte).
- Gran comunidad de usuarios. Alto nivel de respuesta y participacin.
- Documentacin: Clara, amplia y ordenada. Orientada a ejemplos y de fcil
lectura.
- Dos modos de trabajo: Embebido y Cliente/Servidor.
- Transparencia Persistente / Consultas Nativas.
- Soporte de versionado.
- Portabilidad entre .Net, Mono y Java.
- Transacciones ACID: Atomicidad, Consistencia, Aislamiento, Durabilidad.
- Clientes de peso avalan su uso: BMW, Intel, Boeing, Ricoh, Seagate, Bosch,
Novell, etc.
Instalacin
Para empezar a utilizar db4o, es necesario descargar la versin apropiada para su
equipo. Actualmente existen versiones para .NET 1.x y 2.0, para Java y para Mono.
.NET
Lo primero que necesita saber es qu versin de .NET est instalada en su computadora.
Una comprobacin rpida es observar si existe un directorio parecido a
"c:\WINDOWS\Microsoft.NET\Framework\", all dentro debera tener un subdirectorio
con el nmero de versin (ver tabla abajo) por cada versin instalada. La versin ms
profesional de esta verificacin es ejecutar el siguiente script .VBS:
strComputer = "."
Set objWMIService = GetObject("winmgmts:\\" & strComputer &
"\root\cimv2")
Set colItems = objWMIService.ExecQuery("Select * from Win32_Product")
For Each objItem in colItems
If InStr(objItem.Name, "Microsoft .NET Framework") > 0 Then
Wscript.Echo objItem.Version
End If
Next
* Debera aparecer un cuadro de dilogo por cada versin instalada.
Si no ha actualizado el framework .NET separadamente, la siguiente tabla puede darle
una idea de la versin instalada en su equipo:
Visual Studio .NET Nombre de Versin Nmero de versin
2002 1.0 Beta 1 1.0.????.0
2002 1.0 Beta 2 1.0.2914.0
2002 1.0 RTM 1.0.3705.0
2002 1.0 SP1 1.0.3705.209
2002 1.0 SP2 1.0.3705.288
2002 1.0 SP3 1.0.3705.6018
2003 1.1 RTM 1.1.4322.573
2003 1.1 SP1 1.1.4322.2032
2003* 1.1 SP1 1.1.4322.2300
2005 2.0 Beta 1 2.0.40607
2005 2.0 RTM 2.0.50727.42
- 3.0 RTM 3.0.4506.30
* = (Windows Server 2003 Version)
Si tiene varias versiones de .NET instaladas, es posible especificar con qu versin
desea utilizar db4o editando un archivo de configuracin de la aplicacin [1] (que no es
ms que un XML con extensin .config), sin embargo esto no es necesario ya que por
omisin db4o tomar la ltima versin de .Net instalada.
La distribucin de Db4o para .NET consiste en un archivo instalador MSI, por lo que
deber tener habilitado el servicio "Windows Installer" para poder instalarlo. Ingrese en
la "Consola de administracin de Microsoft" escribiendo services.msc en Inicio ->
Ejecutar para poder habilitarlo si no est ya habilitado.
Java
Para empezar se debe tener instalada la mquina virtual Java de Sun (JRE). Por el uso de
los generics y mejoras en la ejecucin del for, se recomienda utilizar Java 5.0 en lo
posible. Db4o tambin corre sobre la mquina virtual Java de Microsoft, para la cual se
debe utilizar JDK 1.1 a partir de la versin 6.1 de Db4o.
Db4o puede ejecutarse sobre las plataformas Java J2EE, J2SE y dialectos J2ME que
soporten reflexin computacional como CDC, PersonalProfile, Symbian, Savaje y
Zaurus. Est planeado el soporte sobre dialectos sin reflexin como CLDC, Palm OS y
RIM/Blackberry.
La distribucin para Java viene en formato ZIP que debemos extraer en donde creamos
conveniente.
Lenguajes
La siguiente tabla presenta los lenguajes y entornos soportados por Db4o:
Lenguaje/Entorno Soporte
C# S
Java (JRE) S
Java (J#) S
VisualBasic.Net S
Delphi.NET S
C++ Administrado (C++/CLI)
Ruby (JRuby) Va reflector
Python (IronPython) S
Python (Jython) Va reflector
Boo S
ASP.NET S
Compact Framework S
Configuracin
Suficiente hasta aqu con cuestiones de instalacin. Db4o posee dos modos de trabajo:
Embebido y Cliente/Servidor. A los propsitos de este artculo solo veremos el primer
modo, dejando a futuras revisiones el modo cliente/servidor.
Para poder distribuir aplicaciones con db4o, slo necesita copiar una librera (.dll) muy
pequea y configurar algunas cosas en su entorno de desarrollo preferido (adems de
escribir el cdigo necesario desde luego!).
VisualStudio .NET 2005
Estos son los pasos para comenzar a desarrollar con db4o 6.0 bajo este entorno:
1. Agregar la referencia de la dll en nuestro proyecto haciendo click con el botn
derecho sobre References en el Solution Explorer.
2. Elegir Add Reference y luego Browse
3. Seleccionar db4o.dll, Open y finalmente Ok
Y listo. No es necesaria la administracin de la base de objetos. Los pasos de
configuracin son similares para el entorno SharpDevelop
Eclipse
Slo hay que agregar las referencias al .jar correspondiente al entorno de trabajo.
1. Abrir las propiedades del proyecto haciendo click con el botn derecho sobre el
proyecto en el Package Explorer y seleccionando Properties.
2. Seleccionar Java Build Path y hacer click sobre la pestaa Libraries.
3. Agregar el JAR correspondiente haciendo click en el botn Add External JARs y
navegando hasta encontrar el JAR para la versin de Java que est utilizando.
Ejemplo: Tienda de renta de DVDs
Vamos a trabajar con un ejemplo tpico. Supongamos un cliente que hace un alquiler en
nuestra tienda de renta de DVDs. A modo de ejemplo instanciemos una pelcula y su
respectiva copia fsica del DVD en nuestro sistema, y posteriormente un nuevo alquiler
del cliente, asociando la informacin correspondiente. Grficamente nuestras instancias
quedaran as:
Por ahora, supongamos tambin que para el siguiente cdigo de ejemplo tenemos un
objeto db sobre el cual se pueden realizar dos operaciones, Set() y Commit(), que
persisten los datos. El cdigo que generara nuestras instancias sera algo como lo
siguiente:
Java
(El proyecto que prueba este Script se llama ConsoleApplicatioDb4oTest-SimpleScript-JAVA)
C#
(El proyecto que prueba este Script se llama ConsoleApplicatioDb4oTest-SimpleScript-CS)
Si nunca trabaj con bases de objetos es importante que tenga en cuenta lo siguiente: En
Db4o, las referencias a los objetos especifican la relacin entre ellos, por lo tanto en
nuestro ejemplo, la pelcula (unaPelicula) y la copia fsica (copiaDVD) son almacenados
implcitamente al hacer db.Set(alquiler). El db.Commit() finalmente cierra la
transaccin. Es fundamental que recuerde esta especie de principio que determina el
funcionamiento de las bases de objetos.
Hasta aqu podemos sacar varias conclusiones. Como observamos, con db4o no es
necesario crear un esquema de persistencia, es decir, no hay que hacer el diseo de la
base de datos ya que es el modelo de clases de nuestro sistema lo que se persiste. Esto
nos libera de varias cosas, entre ellas, el uso de herramientas de administracin de base
de datos, un administrador de base de datos, y de poseer conocimientos bases de datos
relacionales (lgebra relacional, SQL), entre otras tareas.
Para los siguientes ejemplos, puede ser til ir inspeccionando la base mientras se trabaja
con ella. Db4o posee un explorador con el cual podemos navegar nuestras bases y
realizar copias de seguridad, defragmentaciones, consultas, etc. Este se llama Object
Manager, y se puede descargar desde el Centro de Descargas de Db4o (ver seccin de
// Creamos una nueva pelcula
Pelicula unaPelicula = new Pelicula("The Godfather", Francis Ford
Coppola);
// Creamos un nueva copia fsica para la pelcula
// y asociamos la pelcula a la copia fsica
Dvd copiaDVD = new Dvd(5, unaPelicula);
// Alquiler por 2 das
Alquiler alquiler = new Alquiler ("Juan Perez", copiaDVD, 2);
// Finalmente almacenamos el alquiler
db.set(alquiler);
db.commit();
// Creamos una nueva pelcula
Pelicula unaPelicula = new Pelicula("The Godfather", Francis Ford
Coppola);
// Creamos un nueva copia fsica para la pelcula
// y asociamos la pelcula a la copia fsica
Dvd copiaDVD = new Dvd(5, unaPelicula);
// Alquiler por 2 das
Alquiler alquiler = new Alquiler ("Juan Perez", copiaDVD, 2);
// Finalmente almacenamos el alquiler
db.Set(alquiler);
db.Commit();
enlaces). En la seccin de herramientas de este artculo incluimos un listado de otras
utilidades para db4o. Desde el Object Manager entonces, nuestro alquiler recientemente
almacenado en la base, se vera de la siguiente manera:
Haciendo click en el cono del rbol de cada tem, se muestra una vista jerrquica del item seleccionado.
Para poder ejecutar el Object Manager, deber tener instalada una mquina virtual Java
en su sistema (por ejemplo el llamado Java Runtime Environment o JRE). La forma
correcta de ejecucin entonces es llamando al archivo por lotes (.bat) que se encuentra
dentro de la carpeta del Object Manager y es el encargado de instanciar el applet de Java
(.jar).
Entorno de trabajo
En el CD se encuentran dos proyectos para VisualStudio: uno que incluye acceso va S.O.D.A. y otro
mediante Consultas Nativas, temas que trataremos a continuacin. Ambos proyectos estn a la XP, es
decir, se incluyen tests Nunit para verificar su correcto funcionamiento.
En principio hagamos algunas consultas muy simples sobre Pelicula, a fin de
familiarizarnos con el acceso a db4o, y luego nos moveremos a algunas ms
interesantes.
Trabajaremos con C# y Java que son los lenguajes ms populares en la comunidad de
db4o. En ambos casos, primero deber incluir las rutas necesarias para que el enlazador
encuentre los mtodos:
Java
import com.db4o.Db4o;
import com.db4o.Query;
C#
using Db4objects.Db4o;
using Db4objects.Db4o.Query;
La API de db4o es similar en todos los lenguajes soportados. Usualmente la forma de
trabajo es similar al siguiente molde:
Java
// Crear una base si no existe, abrirla si ya existe.
File file = new File("testDb4o.yap");
String fullPath = file.getAbsolutePath();
ObjectContainer db = Db4oFactory.openFile(file);
try
{
// realizar alguna accin con db4o
// Ejemplos :
db.set(obj); // Almacena un objeto en la base
db.commit(); // Realizar la transaccin (y arrancar otra)
db.delete(obj); // Eliminar un objeto en la base
}
finally
{
db.close(); // Cerrar la base y liberar los recursos
}
C#
// Crear una base si no existe, abrirla si ya existe.
IObjectContainer db = Db4oFactory.OpenFile("testDb4o.yap");
try
{
// realizar alguna accin con db4o
// Ejemplos :
db.Set(obj); // Almacena un objeto en la base
db.Commit(); // Realizar la transaccin (y arrancar otra)
db.Delete(obj); // Eliminar un objeto en la base
}
finally
{
db.Close(); // Cerrar la base y liberar los recursos
}
La base de objetos consta de un archivo denominado YAP, en donde se almacenarn los
objetos serializados. A nivel de aplicacin se lo llama ObjectContainer y es el objeto
sobre el cual se realizarn las operaciones de persistencia (Set(), Get(), Commit(), etc.).
En los ejemplos a continuacin, asumiremos que el cdigo se ejecuta dentro del bloque
try { }, y estn incluidos los espacios de nombres citados arriba a fin de que se
encuentren las funciones necesarias.
Acceso a Db4o
Antes de ver las formas de acceso a datos en Db4o, vamos a ponernos un poco en
contexto: El acceso a los datos en una base de objetos es navigacional. La eficiencia en
velocidad (una de las caractersticas notables de db4o) viene dada por el hecho de que
las referencias son almacenadas directamente en cada instancia, mientras que en las
bases de datos tradicionales (que fueron realizadas antes de que el mecanismo de
herencia fuera ampliamente utilizado), el acceso es tabular, y lo que generalmente se
intenta en estos casos para salvar la distancia con el mundo de objetos, es utilizar
mapeadores Objeto-Relacionales, que incluyen APIs o lenguajes que dan la ilusin de
trabajar con objetos.
En db4o existen tres formas de realizar consultas, cada una basada en una tecnologa
diferente. Estas son:
S.O.D.A.: Simple Object Database Access / Acceso Simple a Bases de Datos de Objetos.
Q.B.E.: Query By Example / Consulta por Ejemplo o Plantilla.
N.Q.: Native Queries / Consultas Nativas
En un principio, db4o permita acceder mediante Q.B.E. y S.O.D.A. [2], siendo esta
ltima la interface preferida por ser una tecnologa desarrollada por el mismo creador
de db4o, Carl Rosenberg. La experiencia tomada con los usuarios durante el perodo
2003 2005 ha valido para dar cuenta de sus limitaciones y proponer una nueva
tecnologa de acceso a datos persistidos, que supliera con estas limitaciones. A partir de
la versin 6 de db4o, las Consultas Nativas (N.Q.) se convirtieron en la interface
principal de acceso, mientras que S.O.D.A. se ha mantenido por cuestiones de
compatibilidad y para el uso de consultas generadas dinmicamente. A pesar de su
reciente inclusin en db4o, las idea detrs de las Consultas Nativas no son un concepto
nuevo; las colecciones de Smalltalk ya incluan esta capacidad desde su especificacin
en 1983. Veamos cuales son sus ventajas y desventajas principales:
Tecnologa Ventajas Desventajas
QBE Simplicidad, recomendada
para principiantes.
Funcionalidades limitadas: Carece de
consultas con juntores (AND, NOT,
OR, etc).
Se necesita agregar un constructor
para crear objetos sin campos
inicializados.
No se puede consultar por valores
nulos
SODA Independencia del lenguaje
de programacin utilizado.
API simple. Minimiza el
uso de cadenas para
consultas
Opera sobre propiedades
Introduce conceptos
relacionados con grafos de
nodos (natural a las bases de
objetos): Descender y
Restringir por nodos que
pueden ser una o muchas
clases, un atributo de una
clase, o consultas mismas.
No se verifican tipos en tiempo de
compilacin
(query.Descend(dirctor) fallara en
tiempo de ejecucin)
Demasiado explcita (verbose).
Opera sobre campos ,
(pelicula._director) en vez de
propiedades (pelicula.getDirector() o
pelicula.Director)
Requiere actualizar las consultas
cuando se refactoriza o modifica el
modelo de clases.
Consultas basadas en cadenas
embebidas son blanco para ataques
va inyeccin de cdigo.
NQs Interface recomendada para
Db4o
100% segura en tipos:
Verificacin de errores
semnticos y sintcticos en
tiempo de compilacin.
100% refactorizable
100% nativas: no hay
necesidad de aprender
lenguajes de consultas o
APIs
Las consultas deben ser traducidas al
lenguaje o API del motor, esto puede
penalizar en rendimiento en el caso
de consultas complejas, donde no es
posible hacerlo sin instanciar algunos
objetos persistidos.
Acceso mediante S.O.D.A. (Simple Object Database Access):
Al trabajar con db4o, debemos imaginar nuestros datos como en un grafo en el que
podemos navegar (o consultar), a diferencia de lo que haramos con una base relacional
donde los datos estn tabulados y la idea predominante es combinar resultados en tablas.
El acceso con S.O.D.A. se realiza mediante la clase Query, que es obtenida a travs del
ObjectContainer. Consideremos algunas operaciones tpicas:
Java
// Instanciamos un objeto query para realizar las consultas
Query query = db.query();
// Indicamos el objeto contra el cual se realizar la consulta
query.constrain(Pelicula.class);
////////////////////////////////////////////////////////////////
// Configuramos la/s consulta/s en el objeto query
////////////////////////////////////////////////////////////////
// Por dato particular : Recuperemos la(s) Pelicula(s) llamada(s)
// El Padrino si existe(n).
query.descend("nombre").constrain("El Padrino");
// Por negacin : Recuperar las pelculas que no se llamen
// El Padrino si existen.
query.descend("nombre").constrain("El Padrino").not();
// Por conjuncin : Recuperar las pelculas llamadas El Padrino y
// cuyo director sea Francis Ford Coppola
Constraint constr = query.descend("nombre").constrain("El Padrino");
query.descend("director").constrain(Francis Ford Coppola).and(constr);
// Por disyuncin : Recuperar las pelculas llamadas El Padrino o
// cuyo director se llame Francis Ford Coppola
Constraint constr = query.descend("nombre").constrain("El Padrino");
query.descend("director").constrain(Francis Ford Coppola).or(constr);
// Por similitud: Recuperar las pelculas que contengan God en su ttulo
IConstraint constr = query.descend("nombre").constrain("God").like();
// Ordenando resultados de forma ascendente
query.descend("nombre").orderAscending();
// Ordenando resultados de forma descendente
query.descend("nombre").orderDescending();
// Ejecutar la consulta y Mostrar los resultados
ObjectSet result = query.execute();
listResult(result);
C#
// Instanciamos un objeto query para realizar las consultas
Query query = db.Query();
// Indicamos el objeto contra el cual se realizar la consulta
query.Constrain(typeof(Pelicula));
////////////////////////////////////////////////////////////////
// Configuramos la/s consulta/s en el objeto query
////////////////////////////////////////////////////////////////
// Por dato particular : Recuperemos la(s) Pelicula(s) llamada(s)
// El Padrino si existe(n).
query.Descend("_nombre").Constrain("El Padrino");
// Por negacin : Recuperar las pelculas que no se llamen
// El Padrino si existen.
query.Descend("_nombre").Constrain("El Padrino").Not();
// Por conjuncin : Recuperar las pelculas llamadas El Padrino y
// cuyo director sea Francis Ford Coppola
Constraint constr = query.Descend("_nombre").Constrain("El Padrino");
query.Descend("_director").Constrain(Francis Ford Coppola).And(constr);
// Por disyuncin : Recuperar las pelculas llamadas El Padrino o
// cuyo director se llame Francis Ford Coppola
Constraint constr = query.Descend("_nombre").Constrain("El Padrino");
query.Descend("_director").Constrain(Francis Ford Coppola).Or(constr);
// Por similitud: Recuperar las pelculas que contengan God en su ttulo
IConstraint constr = query.Descend("_nombre").Constrain("God").Like();
// Ordenando resultados de forma ascendente
query.Descend("_nombre").OrderAscending();
// Ordenando resultados de forma descendente
query.Descend("_nombre").OrderDescending();
// Ejecutar la consulta y Mostrar los resultados
ObjectSet result = query.Execute();
listResult(result);
Observamos en los ejemplos previos que mediante una consulta se desciende por los
nodos especificando un atributo. Estos nodos pueden referir a tanto tipos primitivos
como String en los ejemplos de _nombre o _director, o bien referir a otros objetos de
nuestra aplicacin, como veremos adelante en el ejemplo de acceso a objetos anidados.
Finalmente, se restringe por el dato que queremos consultar ("El Padrino", Stanley
Kubrick, Pelicula, DVD, etc). Observemos que las restricciones se dan en dos lugares:
Al comienzo, cuando especificamos la clase de lo que queremos obtener
(query.Constrain(typeof(Pelicula))) y al final mismo (Constrain(Francis Ford
Coppola)).
A su vez, estas restricciones (Constraints), se pueden combinar mediante juntores (Or,
And, Not) y operadores de comparacin (Equal, Identity, Like, Contains, Smaller,
Greater, etc).
Por lo tanto, descender y restringir son bsicamente las ideas principales con
S.O.D.A.. Descender por una consulta da como resultado otra consulta, a la cual
podemos descender nuevamente y realizar la restriccin que nos interese:
Java
// Acceso a objetos anidados
query.constrain(Alquiler.class);
query.descend("copiaFisica").descend("pelicula").constrain(nombre);
C#
// Acceso a objetos anidados
query.Constrain(typeof(Alquiler));
query.Descend("copiaFisica").Descend("pelicula").Constrain(_nombre);
Aqu restringimos por Alquiler, descendimos dos niveles por copiaFisica y pelicula,
para luego restringir por nombre.
Esta idea de descenso, conlleva de por s la idea de profundidad. Veamos un caso en
donde la profundidad es importante, la actualizacin de objetos. Pongamos por ejemplo
que deseamos actualizar una Pelcula:
Java
// Obtenemos una pelcula utilizando un prototipo
1. Query query = db.query();
2. ObjectSet result = db.get(new Pelicula("El laberinto del Fauno"));
3. Pelicula found = (Pelicula)result.next();
// Actualizar el director
4. found.director = Guillermo del Toro;
5. db.set (found);
// Mostrar resultados
6. Result = db.get (new Pelicula("El laberinto del Fauno"));
7. listResult(result);
C#
// Obtenemos una pelcula utilizando un prototipo
1. Query query = db.Query();
2. ObjectSet result = db.Get(new Pelicula("El laberinto del Fauno"));
3. Pelicula found = (Pelicula)result.Next();
// Actualizar el director
4. found.Director = Guillermo del Toro;
5. db.Set (found);
// Mostrar resultados
6. Result = db.Get (new Pelicula("El laberinto del Fauno"));
7. listResult(result);
Observamos una forma alternativa de recuperar un objeto, especificando un prototipo, el
equivalente de las lneas 2 y 3 sin prototipos sera:
C#
1. Query query = db.Query();
2. query.Constrain(typeof(Pelicula));
3. query.Descend("_name").Constrain("El laberinto del Fauno");
ObjectSet result = query.Execute();
Java
1. Query query = db.query();
2. query.constrain(Pelicula.class);
3. query.descend("name").constrain("El laberinto del Fauno");
ObjectSet result = query.execute();
Volviendo a la cuestin de la profundidad: Por omisin, slo se actualizar el objeto
pasado como parmetro al mtodo Set(), es decir, los miembros primitivos de ese objeto,
por ello la profundidad de actualizacin (update depth) ser igual a 1. Es importante
recordarlo ya que en general un modelo de objetos medianamente complejo
seguramente utilizar ms de un nivel de contencin de objetos que no son primitivos.
Si quisiramos actualizar los objetos miembros, es decir, aquellos que estn asociados a
un objeto, debemos configurar el objeto raz en cuestin para que actualice el grafo a la
profundidad deseada.
Java
// Actualizar el grafo completo de objetos desde Pelicula
Db4o.configure().objectClass(Pelicula.class).cascadeOnUpdate(true);
C#
// Actualizar el grafo completo de objetos desde Pelicula
Db4o.Configure().ObjectClass(typeof(Pelicula)).CascadeOnUpdate(true);
En general es conveniente realizar un plan de actualizacin de tal forma que al ejecutar
las consultas, slo se recuperen aquellos objetos que necesiten actualizarse y no ms, a
fin de no penalizar en velocidad de acceso.
Acceso mediante Consultas Nativas (NQs):
Como vimos, una base de objetos en db4o se crea mediante cdigo escrito en el mismo
lenguaje de desarrollo de la aplicacin (C#, Java, Visual Basic, etc.), por lo que no es
necesario aprender otros lenguajes como SQL, HQL de Hibernate, OQL, JDOQL,
EJBQL, o SODA (adems del lenguaje de desarrollo elegido) para persistir nuestros
datos. Esta caracterstica es llamada Transparencia Persistente, "Native Queries" o
simplemente NQs, y est marcando una tendencia entre los usuarios de Db4o. An
cuando considere que el uso o aprendizaje de otro lenguaje no es realmente relevante,
existe otra gran dificultad con los lenguajes de consultas, y es que estn basados en
cadenas. Estas cadenas deben ser analizadas lxicamente y sintcticamente por el parser
del motor de persistencia, esto desde ya aade tiempo y es un proceso propenso a
errores. S.O.D.A incluso, que minimiza el uso de cadenas, tambin tiene la dificultad de
que el compilador no puede verificar la validez del atributo de una clase.
Sin embargo, internamente, las Consultas Nativas funcionan sobre S.O.D.A., por lo que
existe un conversor y un optimizador de consultas llamado Native Query Optimizer
para maximizar su rendimiento.
En concreto, la idea tras NQs es posibilitar la forma ms simple posible de realizar una
consulta. Esta forma ms simple trabajara con una instancia prototpica, es decir, una
creada como si fuera un ejemplo, pero que representa a todas las de su tipo.
Naturalmente esto sera algo tan simple como:
Java
// Obtener las pelculas que contienen la cadena Padrino
Pelicula.getNombre().contains(Padrino);
C#
// Obtener las pelculas que contienen la cadena Padrino
Pelicula.Nombre.Contains(Padrino);
Siempre tenemos que tener en cuenta que lo principal de la consulta es esta expresin,
que realiza la accin que nos interesa. A partir de aqu en adelante lo que veremos es de
algn modo, cmo conformar a cada compilador y al motor de Db4o para que acepten
esta expresin de la forma ms simple posible. Esto no es fundamental, ni tampoco es
complejo, pero s es necesario aprenderlo para poder utilizar Consultas Nativas.
Para que esto funcione entonces, lo primero que necesitaramos es especificarle el tipo
de esta instancia prototpica (pelcula) a la expresin sobre la cual realizamos la
consulta, y devolver los resultados en algn tipo de contenedor. Algo como:
Java
// Obtener las pelculas que contienen la cadena Padrino
(Pelicula pelicula) {
return pelicula.getNombre().contains(Padrino);
}
C#
// Obtener las pelculas que contienen la cadena Padrino
(Pelicula pelicula) {
return pelicula.Nombre.Contains(Padrino);
}
La prxima caracterstica a agregar a la expresin necesita una introduccin. Hace un
instante mencionamos que, internamente, db4o realiza un proceso de anlisis,
conversin y posible optimizacin sobre las consultas. Esto agrega un nuevo
requerimiento a nuestra expresin, que debera ser de tal forma que pueda pasarse como
parmetro al motor de la base de objetos, u otro procesador de consultas, y as poder ser
modificada.
Siempre priorizando la simplicidad sintctica, necesitaramos entonces un objeto que
pueda referenciar una especie de mtodo annimo que sea usado como parmetro y
sea modificable, ya sea bien optimizndose o simplemente traducindose a SODA. Esto
es posible a partir de .NET 2.0 utilizando los llamados delegados. Un delegado es como
un par objeto-mtodo que funciona como una retrollamada (callback), y sirve para tratar
a un mtodo como un objeto de primera clase, y as pasarse como parmetro a otros
mtodos. Los delegados son muy usados en el mundo de .NET para realizar
notificaciones de eventos, ejecuciones encadenadas y algunos otros casos en los que se
necesite reflexin computacional.
En Java 1.2 1.4 y 5.0, es posible emular este comportamiento utilizando la clase
Predicate como una clase annima, y escribiendo en un mtodo match la expresin
dentro de ella, un detalle que le resta simplicidad en comparacin con la versin de C#.
En el caso particular de Java 5.0, se puede hacer uso de los generics. En cdigo esto
sera:
Java
// Obtener las pelculas que contienen la cadena Padrino
new Predicate() {
public boolean match(Pelicula pelicula) {
return pelicula.getNombre().contains(Padrino);
}
C#
// Obtener las pelculas que contienen la cadena Padrino
delegate (Pelicula pelicula) {
return pelicula.Nombre.Contains(Padrino);
}
Lamentablemente la sintaxis para definir mtodos annimos en C# y Java an es algo
excesiva (esto tal vez cambie en el futuro con versiones posteriores de los lenguajes), en
comparacin con sus definiciones equivalentes en otros lenguajes, por ejemplo las
expresiones lambda en Haskell o los CompiledMethods o bloques de Smalltalk. An as
pese a esta desventaja, en nuestra opinin, su uso es recomendable considerando sus
contrapartes en lenguajes como SQL o lenguajes de consultas basadas en cadenas,
propensos a errores de tipeo, dificultades para depuracin, y a utilizar cientos de
palabras claves. Existen tambin algunas ventajas adicionales como la posibilidad de
realizar consultas dinmicas y parametrizadas, temas que podran tratarse en futuros
artculos.
Volviendo a nuestra expresin, finalmente agregamos el contenedor para los resultados,
quedando:
Java 5.0
List <Pelicula> peliculas = database.query <Pelicula> (
new Predicate <Pelicula> () {
public boolean match(Pelicula pelicula) {
return pelicula.getNombre().contains(El Padrino);
}
});
Java 1.2 1.4
List peliculas = database.query (
new Predicate () {
public boolean match(Pelicula pelicula) {
return pelicula.getNombre().contains(El Padrino);
}
});
C# .NET 2.0
IList <Pelicula> peliculas = db.Query <Pelicula> (
delegate (Pelicula pelicula) {
return pelicula.Nombre.Contains(El Padrino);
});
C# .NET 1.1
IList <Pelicula> peliculas = db.Query (new PeliculaQuery());
Public class PeliculaQuery : Predicate
{
Public boolean match(Pelicula pelicula) {
return pelicula.Nombre.Contains(El Padrino);
}
};
Vamos ahora a reescribir nuestras consultas S.O.D.A, a la Consultas Nativas:
Java
// Consulta por dato particular : Recuperar la(s) Pelicula(s)
// llamada(s) El Padrino si existe(n).
List <Pelicula> peliculas = this.db.query(new Predicate<Pelicula>() {
public boolean match (Pelicula pelicula) {
return pelicula.get_nombre().equals(El Padrino);
}});
// Por negacin : Recuperar las pelculas que no se llamen
// El Padrino si existen.
List <Pelicula> peliculas = this.db.query(new Predicate<Pelicula> (){
public boolean match (Pelicula pelicula) {
return !pelicula.get_nombre().equals(El Padrino);
}});
// Por conjuncin : Recuperar las pelculas llamadas El Padrino y
// cuyo director sea Francis Ford Coppola
List <Pelicula> peliculas = this.db.query(new Predicate <Pelicula>
(){
public boolean match (Pelicula pelicula) {
return pelicula.get_nombre().equals(El Padrino) &&
pelicula.get_director().equals(Francis Ford Coppola);
}});
// Por disyuncin : Recuperar las pelculas llamadas El Padrino o
// cuyo director se llame Stanley Kubrick
List <Pelicula> peliculas = this.db.query(new Predicate <Pelicula>(){
public boolean match (Pelicula pelicula) {
return pelicula.get_nombre().equals(El Padrino) ||
pelicula.get_director().equals(Stanley Kubrick);
}});
// Por similitud: Recuperar las pelculas que contengan God en su ttulo
List <Pelicula> peliculas = this.db.query(new Predicate <Pelicula>(){
public boolean match (Pelicula pelicula) {
return pelicula.get_nombre().contains("God");
}});
// Ordenacin: Alfabticamente por nombre especificando un criterio
// de comparacin con un delegado annimo
Comparator<Pelicula> peliculaCmp = new Comparator<Pelicula>() {
public int compare (Pelicula pel1, Pelicula pel2){
return pel1.get_nombre().compareTo(pel2.get_nombre());
}
};

List <Pelicula> peliculas = this.db.query(new Predicate<Pelicula>() {
public boolean match (Pelicula pelicula) {
return true;
}
}, peliculaCmp);
C#
// Consulta por dato particular : Recuperar la(s) Pelicula(s)
// llamada(s) El Padrino si existe(n).
IList<Pelicula> peliculas = db.Query<Pelicula>(delegate(Pelicula
peliculaDb) {
return peliculaDb.Nombre(El Padrino );
});
// Por negacin : Recuperar las pelculas que no se llamen
// El Padrino si existen.
IList<Pelicula> peliculas = db.Query<Pelicula>(delegate(Pelicula
peliculaDb) {
return peliculaDb.Nombre(El Padrino );
});
// Por conjuncin : Recuperar las pelculas llamadas El Padrino y
// cuyo director sea Francis Ford Coppola
IList<Pelicula> peliculas = db.Query<Pelicula>(delegate(Pelicula
peliculaDb) {
return (peliculaDb.Nombre == El Padrino) &
(peliculaDb.Director == Francis Ford Coppola); });
// Por disyuncin : Recuperar las pelculas llamadas El Padrino o
// cuyo director se llame Stanley Kubrick
IList<Pelicula> peliculas = db.Query<Pelicula>(delegate(Pelicula
peliculaDb) {
return (peliculaDb.Nombre == El Padrino) |
(peliculaDb.Director == Stanley Kubrick); });
// Por similitud: Recuperar las pelculas que contengan God en su ttulo
IList<Pelicula> peliculas = db.Query<Pelicula>(delegate(Pelicula
peliculaDb) {
return (peliculaDb.Nombre.Contains == God); });
// Ordenacin: Alfabticamente por nombre especificando un criterio de
// comparacin con un delegado annimo
Comparison<Pelicula> peliculaCmp = new
Comparison<Pelicula>(delegate(Pelicula p1, Pelicula p2)
{
return p2.Nombre.CompareTo(p1.Nombre);
});
IList<Pelicula> peliculas = db.Query<Pelicula>
(delegate(Pelicula peliculaDb) { return true; }, peliculaCmp);
Debido a las ventajas mencionadas anteriormente, existe dentro de la comunidad Db4o
una marcada tendencia hacia las Consultas Nativas a pesar de su reciente novedad en el
mundo de desarrolladores Java y .Net. Una forma conveniente de acostumbrarse al
trabajo con Consultas Nativas es primero escribir la expresin de la consulta, luego
agregar la coleccin devuelta, y finalmente encabezado correspondiente al delegado
para C# o el predicado en el caso de Java, que suelen tener una forma ms similar entre
todas ellas.
Muchos desarrolladores configuran y utilizan unos archivos en formato XML llamados
snippets en VisualStudio o templates en Eclipse, que insertan el texto reusable en
nuevos contextos o aplicaciones (boilerplates) y pueden ser de especial utilidad en estos
casos.
Herramientas
Existen algunas herramientas y conectores (plugins) adicionales interesantes,
descargables desde el Centro de Descargas de Db4o:
ObjectManager GUI Administration Tool: Es una interface grfica realizada en Java
para manipular bases Db4o.
db4o Replication System (dRS): Es una herramienta de compatibilidad basada en
Hibernate (un framework de persistencia y de mapeo objeto-relacional muy popular)
que permite replicar datos desde db4o hacia db4o o algn RDBMS, o bien desde un
RDBMS hacia db4o.
Db4o.Binding.NET: Incluye clases para trabajo con listas en memoria y enlace de
resultados de consultas con controles de Windows Forms y Windows Presentation
Forms (parcialmente). Soporta consultas, filtros, ordenacin, paginacin, etc.
Db4o Eclipse: Plugin documentado para Eclipse con acciones para realizar copias de
resguardo, defragmentacin, etc.
Conclusin
Tal vez le haya sorprendido lo poco que hay que aprender con db4o. En la jerga
acadmica esto se llama gap semntico, lo que significa en pocas palabras, es que el
uso de la tecnologa de objetos (T.O.) est ms cerca del lenguaje natural de los
humanos, por el simple hecho de que requiere que usted conozca menos cuestiones
relacionadas con la mquina en s. Esto permite a los desarrolladores concentrarse ms
en el problema a resolver, el llamado dominio del sistema, en vez de invertir tiempo en
cuestiones propias de la tecnologa elegida.
Enlaces
Sitio
http://www.db4o.com/espanol (con documentacin en castellano)
Foro
http://developer.db4o.com/forums/15/ShowForum.aspx (para interactuar con la
comunidad)
Wiki
http://developer.db4o.com/ProjectSpaces/view.aspx/Espanol (un espacio web gratuito de
trabajo comunitario en castellano)
Blog
http://developer.db4o.com/blogs/espanol/default.aspx (para anuncios y noticias)
Centro de Descargas:
http://developer.db4o.com/files
Descargas de la Comunidad Hispana
http://developer.db4o.com/files/folders/spanish/default.aspx
Referencias
[1] Cmo: Utilizar el archivo de configuracin de una aplicacin para determinar la
versin de .NET Framework que se va a usar : http://msdn2.microsoft.com/es-
es/library/9w519wzk(VS.80).aspx
[3] Sitio de S.O.D.A. http://sodaquery.sourceforge.net
[2] David Taylor. Object Technology. Editorial Addison Wesley (2da Ed. 1997) captulo
6.
[3] William R. Cook, Carl Rosenberg. Native Queries for Persistent Objects. A Design
White Paper. National Science Fundation (15 de febrero de 2006).
[4] Adele Goldberg, D. Robson. Smalltalk-80: the Language and Its Implementation.
Editorial Addison Wesley (1983).
[5] JRE Test (verificar si est instalada y funcional la mquina virtual de Java de Sun)
http://java.com/en/download/help/testvm.xml
[6] Mquina Virtual de Java de Sun : http://developers.sun.com/downloads/top.jsp
[7] Jim Paterson, Stefan Edlich, Henrik Horning, Reidar Horning. The definitive guide
to Db4o. Apress (2006).