\title{db4o2D \-- Extension de Base de donn\'ees Orient\'ee Objet ...}
\subtitle{... pour les types g\'eospatiaux 2D}
\author{Stefan Keller, traduit par Guillaume Sueur}
\maketitle

db4o signifie ``database for objects'', c'est-\`a-dire Base de donn\'ees Orient\'ee Objet. C'est un syst\`eme de gestion de base de donn\'ees orient\'e objet (OODBMS ou SGDBOO en fran\c{c}ais) \'ecrit en Java et en .NET et de ce fait destin\'e \`a ces deux plateformes. Ce logiciel a \'et\'e initialement publi\'e en 2001 par db4Objects, Inc., et depuis lors s'est taill\'e une part majeure du march\'e de ce qu'on peut appeler les bases de donn\'ees objet de deuxi\`eme g\'en\'eration. Il est disponible sous deux licences ("dual licensing model"), une licence OpenSource de type GPL pour l'utilisation personnelle et non-commerciale mais aussi une license commerciale.

% sans avoir l'original, je me demande si la relation GPL / non commercial n'est pas mal passee a la traduction. Ce n'est pas clair, et ce qui est sur c est que la GPL n'empeche pas une utilisation commerciale.

Dans cet article, nous pr\'esenterons tout d'abord db4o. Dans le chap\^itre \textit{OODBMS et db4o}, nous en pr\'esenterons les avantages, limites et diff\'erences d'un point de vue conceptuel mais aussi selon une approche de d\'eveloppeur. Puis nous ferons une pr\'esentation de la th\`ese d'un \'etudiant nomm\'ee db4o2D. Enfin nous concluerons sur les perspectives du projet db4o2D.


\section{Premiers pas avec db4o}

Commen\c{c}ons avec un peu de code source afin d'avoir une id\'ee de la facilit\'e avec laquelle on peut cr\'eer des objets persistants. Notre premier exemple met en oeuvre les quatre c\'el\`ebres op\'erations de base en mati\`ere de bases de donn\'ees : Cr\'eer, Lire, Mettre \`a jour, Supprimer (CRUD en anglais, pour Create, Read, Update and Delete). Cet exemple se base sur un objet Personne dot\'e des attributs nom, pr\'enom et date de naissance. 

\begin{smallverbatim}
// 1: Initialisation d'un objet conteneur
ObjectContainer db= null;
try {
    // 2: Ouverture de la base db4o en mode integre
    db= Db4o.openFile("addressbook.yap");

    // 3: Creation et stockage de quelques 'Kellers'
    db.set(new Person("Brian", "Keller", 1960));
    db.set(new Person("Clara", "Keller"));
    db.set(new Person("Test"));

    db.commit();

    // 4: Recherche et lecture de tous les Keller
    // Avec une "Requete par l'exemple"
    ObjectSet result= db.get( \
        new Person(null, "Keller", 0));
    while (result.hasNext())
        System.out.println( \ 
            (Person) result.next());

    // 5: Mise a jour de l'age de Clara
    result= db.get(new Person("Clara", "Keller"));
    Person found= (Person) result.next();
    found.setYearOfBirth(1970);
    db.set(found);

    // 6: Suppression de la donnee de Test
    result= db.get(new Person("Test"));
    while (result.hasNext())
        db.delete(result.next());

    // 7: Enregistrement des modifications
    db.commit();
} finally {
    if (db != null)
        db.close();
}
\end{smallverbatim}

\textit{Fig. 1. Morceau de code montrant les op\'erations CRUD sur des objets personnes stock\'es dans un carnet d'adresses.}


Dans cet exemple, nous parcourons les \'etapes suivantes qui illustrent quelques op\'erations CRUD:
\begin{enumerate}
\item Cette instruction initialise un conteneur dans lequel db4o manipule l'ensemble des objets persistants de mani\`ere transactionnelle. 
\item La deuxi\`eme instruction ouvre un fichier de base de donn\'ees db4o. Nous proposons l'utilisation de l'extension .yap mais ce n'est pas standardis\'e. Il y a une explication officielle qui indique qu'il s'agit de l'abbr\'eviation de 'yet another protocol' ('encore un nouveau protole' NdT). De mani\`ere non officielle, cette extension se r\'ef\`ere \`a Yap, une petite \^ile de Micron\'esie. Comme indiqu\'e, nous choisissons d'utiliser db4o en mode int\'egr\'e, mais il existe aussi un mode client-serveur.
\item Avec la m\'ethode \texttt{set()} d'un \texttt{ObjectContainer} trois personnes nouvellement cr\'e\'ees sont stock\'ees. Avec le  \texttt{commit()} tous les objets cr\'e\'es, modifi\'es ou supprim\'es sont alors synchronis\'es avec le fichier de base de donn\'ees.
\item Dans cette \'etape nous parcourons tous les objets de la base de donn\'ees dont le nom est \'egal \`a 'Keller', et bouclons ensuite sur le r\'esultat. Dans cet exemple, la 'requ\^ete par l'exemple' est utilis\'ee parmi les trois langages d'interrogation disponibles dans db4o.
\item Lors de la cr\'eation de  ``Clara Keller'' \`a l'\'etape 3 nous avons oubli\'e la date de naissance lors de l'appel du constructeur (car il est poli de ne pas r\'ev\'eler \`a l'avance l'\^age d'une dame). Maintenant nous d\'esirons vraiment indiquer cette valeur, et donc nous devons trouver les objets tels que 'Clara Keller' et mettre \`a jour le premier que renverra la requ\^ete. Nous utilisons la m\'ethode set() \`a nouveau et pr\'esumons qu'il existe une m\'ethode \texttt{setYearOfBirth()} dans la d\'efinition de la classe Personne.
\item A des fins de d\'emonstration, nous avons pr\'ealablement ins\'er\'e des donn\'ees de test qui vont maintenant \^etre supprim\'ees. Cette fois, tous les objets r\'ecup\'er\'es par la requ\^ete seront d\'etruits par la m\'ethode \texttt{delete()} de l'objet \texttt{ObjectContainer}.
\item Enfin nous terminons avec la m\'ethode \texttt{commit()} et fermons la base de donn\'ees.
\end{enumerate}

Les seules d\'efinitions absentes de ce bout de code sont les instructions d'importation ainsi que celles de la classe Personne qui consiste en trois constructeurs, la m\'ethode \texttt{setYearOfBirth()} et de mani\`ere optionnelle, une m\'ethode \texttt{toString()} pour permettre d'\'ecrire l'objet Personne proprement.

Cela suffit \`a d\'emontrer la simplicit\'e d'une application utilisant db4o. Maintenant nous allons pr\'esenter quelques exemples d'utilisation de SGBDOO, quelques fonctionnalit\'es suppl\'ementaires de db4o avant une pr\'esentation plus large de l'extension qui incorpore les types g\'eom\'etriques dans db4o.

\section{SGBDOO et db4o}
\subsection{Exemples d'utilisation et fonctionnalit\'es}


Quand il n'y a qu'une seule application \`a la fois tournant sur une base de donn\'ee et si c'est une application d\'edi\'ee \`a la mobilit\'e comme on en trouve dans les LBS (Location Based Systems, ou syst\`emes bas\'es sur la localisation) ou dans les logiciels embarqu\'es, cela peut valoir la peine d'essayer un SGBDOO de deuxi\`eme g\'en\'eration. Du fait de leur facilit\'e \`a g\'erer les relations entre objets, les SGBDOO sont intrins\`equement bien adapt\'es lorsque des mod\`eles objet complexes, des structures objet \`a plat ou de grandes arborescences objet sont de mise -- ce qui est de fait souvent le cas dans les Syst\`emes d'Information G\'eographique (SIG) et les LBS. 

Voici quelques-uns des fonctionnalit\'es techniques de db4o :
\begin{itemize}
\item Mode int\'egr\'e et mode client-serveur. 
\item Pas d'administration serveur lors de l'ex\'ecution. Les propri\'et\'es de la base de donn\'ees sont controll\'ees hors de l'application h\^ote.
\item Besoin de peu d'espace disque pour les biblioth\`eques du programme, de m\^eme qu'en m\'emoire lors de l'ex\'ecution.
\item Facilit\'e d'utilisation : db4o utilise des interfaces de programmation d'application (API) r\'eflectives \`a partir de Java et .NET. Il n'y a donc aucune annotation suppl\'ementaire, aucun pr\'e ou post-traitement (ing\'enierie de byte code), aucune sous-classe ou impl\'ementation d'interface \`a effectuer.
\item M\'ethodes de contr\^ole du lazy loading (NdT : technique qui consiste \`a ne charger que le strict n\'ecessaire pour l'ex\'ecution du programme) des relations des objets incorpor\'es.
\item Outils de r\'eplication en modules compl\'ementaires.
\end{itemize}

Comme on pourrait s'y attendre de la part d'une base de donn\'ees, db4o impl\'emente des propri\'et\'es ACID (Atomicit\'e, Consistence, Isolation et Durabilit\'e) qui garantissent des transactions s\^ures : une transaction d\'emarre quand on ouvre ou interroge la base, et se termine avec les m\'ethodes \texttt{commit()} ou \texttt{rollback()}.
Trois approches sont impl\'ement\'ees pour les requ\^etes : la requ\^ete par l'Exemple, les requ\^etes SODA (Simple Object Database Access, ou Objet Simple d'acc\`es \`a la base de donn\'ees) et les 'Requ\^etes natives'. La premi\`ere a \'et\'e mise en pratique plus haut. Les requ\^etes SODA sont plut\^ot comparables \`a celles utilis\'ees dans les environnements ORM (Object Relational Mapping, ou correspondance Objet-Relationnel). Une partie de la th\'eorie mise en oeuvre derri\`ere les Requ\^etes natives provient d'un projet de Microsoft (LINQ 2007).

\subsection{Avantages}
Parler d'environnement ORM nous am\`ene \`a comparer les SGBDOO avec cette approche. db4o est tr\`es rapide si on en croit les bancs d'essai (Polepos 2007). Un argument conceptuel est qu'il n'y a pas d'erreur de correspondance objet/relationnel : aucun ajustement des types ou tailles des donn\'ees (\`a moins de le demander), aucune cr\'eation d'un sch\'ema relationnel s\'epar\'e, pas de langage SQL et pas de requ\^ete textuelle SQL \`a g\'erer. 

Il est donc important de mentionner que db4o propose une int\'eressante prise en charge des techniques de d\'eveloppement agile : c'est parce que les requ\^etes sont \'ecrites dans le langage de l'application (Java, .NET) et sont donc s\^ures pour ce qui est du typage des donn\'ees. Il y a aussi des fonctionnalit\'es sympathiques d'\'evolution des sch\'emas, et pas de SQL. Les ing\'enieurs logiciels ont la vie plus facile qu'avant car ils \'evoluent dans un monde objet \`a la diff\'erence des professionnels des bases de donn\'ees. 

\subsection{Limites}
db4o n'est probablement pas adapt\'e pour l'utilisation dans de grands entrep\^ots de donn\'ees ou le data mining. Il est particuli\`erement non recommand\'e quand plusieurs applications acc\`edent \`a la base de donn\'ees avec de nombreuses vues. Le fait que diff\'erents types de langages soient disponibles pour les requ\^etes montre qu'aucun langage standard et mature n'est disponible en comparaison au pr\'edominant SQL du mod\`ele relationnel. Les contraintes, telles que l'int\'egrit\'e r\'ef\'erentielle ne sont pas (encore) int\'egr\'ees dans ces langages, sauf dans les Requ\^etes Natives qui impl\'ementent simplement des fonctions callback. Pour finir, le manque de standardisation actuel a \'et\'e reconnu. Des actions du Groupe de Management Objet (OMG) sont en cours de mani\`ere \`a avancer vers une nouvelle version de standard ODMG version 4. 

\section{Projet db4o2D}
PlaceLab (Intel 2006) --- un projet Intel --- propose des applications mobiles ou de bureau concernant le positionnement WLAN (Wifi). La base de donn\'ees int\'egr\'ee \`a ce logiciel est une base relationnelle open source embarqu\'ee. Un composant sensible ici est la gestion des points d'acc\`es avec leur position respective.  Cela nous sert de d\'emonstration de base de donn\'ees objet qui remplace la base relationnelle existante et stocke les g\'eom\'etries en tant qu'objets de premi\`ere importance.

Dans un projet de th\`ese (db4o2D 2007), il a \'et\'e d\'ecid\'e d'utilise db4o et d'adapter la tr\`es utilis\'ee Java Topology Suite (JTS 2007). La JTS respecte le standard 'Simple Features (NdT : Objets simples)' (OGC 2006) qui d\'efinit quatre types d'attributs g\'eom\'etriques 2d (2.5D) : le point, la ligne, le polygones ainsi que des manipulations s\^ures sur ceux-ci. 

% manipulations sures ? C\`aD ?

Ainsi, dans la portion de code suivante (c.f. Fig 2.), il est montr\'e comment les points d'acc\`es sans fil sont cr\'e\'es (2), stock\'es (3) et relus (4). Un point contient une paire de valeur de coordonn\'ees et comporte un syst\`eme de r\'ef\'erences spatial et des unit\'es de mesure par d\'efaut. 

\begin{smallverbatim}
// 1: Ouverture de la base de donnees db4o  (mode integre)
db= Db4o.openFile("poidb.yap");

// 2: Preparation de deux points JTS
GeometryFactory factory= new GeometryFactory();
double latitude1= 47.225571, longitude1= 8.822271;
Point pt1= factory.createPoint(new Coordinate(
        longitude1, latitude1));
double latitude2= 47.225582, longitude2= 8.822282;
Point pt2= factory.createPoint(new Coordinate(
        longitude2, latitude2));

// 3: Creation et stockage des points d'acces
db.set(new AccessPoint( \ 
    1001, "802.11g", "wep", 7, pt1));
db.set(new AccessPoint( \ 
    1002, "802.11b", "open", 11, pt2));
db.commit();

// 4: Parcours de tous les points d'acces
ObjectSet result= db.get(new AccessPoint());
while (result.hasNext()) {
    System.out.println( \ 
    (AccessPoint) result.next());
}
\end{smallverbatim}
\textit{Fig. 2. Portion de code avec des points d'acc\`es sans fil qui contiennent une g\'eom\'etrie ponctuelle.}

\section{Conclusion}

Le projet db4o2D deviendra un module compl\'ementaire \`a db4o et est toujours en chantier. Bien que la couche existante d'acc\`es \`a la base de donn\'ees \'etait correctement s\'epar\'ee, il est devenu \'evident que la maintenance du code \'etait rendue plus courte, plus rapide et meilleure du fait de l'utilisation d'un pur SGBDOO.

Les travaux \`a venir incluent un index spatial et des tests de charge pour de grandes bases de donn\'ees, ainsi qu'un mode client-serveur multit\^ache. Les requ\^etes SODA complexes sont un autre probl\`eme. Mais il faut noter que ce n'est pas un obstacle actuellement car les Requ\^etes Natives peuvent \^etre utilis\'ees d'ici l\`a. 

Dans le but de propager les technologies de base de donn\'ees objet, un groupement \`a but non lucratif, ODBMS.ORG (2007) a \'et\'e cr\'e\'e. db4o est un des projets phares dans le domaine des bases de donn\'ees objet et il tente de r\'esoudre les probl\`emes bien connus dans le monde des logiciels embarqu\'es, du d\'eveloppement logiciel, des LBS et des SIG. Sachant que ces probl\`emes sont des pr\'eoccupations depuis un certain temps, on pourrait dire que les SGBDOO de deuxi\`eme g\'en\'eration comme celui-ci sont en quelque sorte un retour vers le futur. 

\section{R\'ef\'erences}
\begin{description}
\item [db4o (2007):] Page d'accueil de db4o et db4ojects, Inc.: \url{www.db4o.com} (derni\`ere visite le 22 octobre 2007).
\item [db4o2D (2007):] db4o2D project space, \\ \url{http://developer.db4o.com} (derni\`ere visite le 22 octobre 2007).
\item [Intel (2006):] Le projet PlaceLab Project, PlaceLab --- un syst\`eme de localisation respectant la vie priv\'ee, \url{www.placelab.org} (derni\`ere visite le 22 octobre 2007).
\item [JavaWPS (2007):] Un syst\`eme de positionnement en Java bas\'e sur les signaux WLAN, \url{www.gis.hsr.ch/wiki/JavaWPS} (derni\`ere visite le 22 octobre 2007).
\item [JTS (2007):] Java Topology Suite, une API de fonctions et pr\'edicats spatiaux 2D, \url{www.vividsolutions.com/jts/JTSHome.htm} (derni\`ere visite le 22 octobre 2007).
\item [LINQ (2007):] Le Projet LINQ, \\ \href{http://msdn.microsoft.com/netframework/future/linq}{http://msdn.microsoft.com/netframework\\/future/linq} (derni\`ere visite le 22 octobre 2007).
\item [ODBMS.ORG (2007):]  Un portail ind\'ependant sur les technologies de bases de donn\'ees objet, \url{www.odbms.org}, (derni\`ere visite le 22 octobre 2007). 
OGC (2006): Sp\'ecifications d'impl\'ementation de l'information g\'eographique de l'OpenGIS - Acc\`es aux Objets Simples - Partie 1 : Architecture commune, \url{www.opengeospatial.org/standards/sfa} (derni\`ere visite le 22 octobre 2007)
\item [PolePosition (2007):] Un banc d'essai des bases de donn\'ees OpenSource, \url{www.polepos.org} (derni\`ere visite le 22 octobre 2007).
\end{description}

\address{Stefan Keller\\
Institute for Software and GISpunkt\\
University of Applied Sciences Rapperswil (UAS HSR)\\
CH-8640 Rapperswil, Switzerland\\
\url{www.ifs.hsr.ch}\\
Stefan Keller est un professeur en syst\`emes d'information enseignant les technologies de bases de donn\'ees et la programmation.\\
\email{stefan.keller AT hsr.ch}}
