Mostra la font per a DAM-M3-UF6. Persistència a bases de dades OO

torna [[ M3 - Programació ]]

== Introducció ==


Hi ha múltiples maneres de gestionar la persistència des de Java, alguns exemples:


{| cellspacing="0" cellpadding="4" border="1"
|-
| BBDD Relacionals
| SQL incrustat (Embedded)
| Per exemple SQLJ
| Utilitza directament SQL
Molt eficient. Poc usat i amb poc suport (Per exemple Eclipse no)
|-
| <br />
| Intermediari (Driver)
| Exemples:
JDBC
ODBC
| Les interfícies són lleugeres, aporten mètodes d'utilitat per facilitar la gestió de les tasques més comuns
|-
| <br />
| Eines específiques
| Eines d'alt nivell:
Hibernate
API de Persistència Java 
| Afegeixen gran abstracció respecte la base de dades, i per tant independència de la tecnologia.
En general requereixen d'un procés previ de configuració
|-
| BBDD OO
| colspan="3" | Llibreries específiques per a cada SGBD OO
|}


En general depèn del tipus de base de dades, les més comuns les BBDD Relacionals.

==  Bases de dades OO ==

Aquests tipus de BBDD emmagatzemen objectes (atributs i mètodes). La persistència és doncs molt més directa, no existeixen les limitacions de les BBDD Relacionals. Des del punt de vista del programador és molt més senzill treballar amb aquest tipus de base de dades (Si es programa amb objectes).

Per contra existeixen poques BBDD OO al mercat, en general no s'utilitzen i conceptualment són difícils d'entendre (com s'emmagatzemen les dades? i els mètodes?...)

Cada objecte guardat s'identifica per un OID (Object Identifier), independent de les dades que conté.

'''ODBMS''' : Object Database Management System


http://en.wikipedia.org/wiki/Object_database
http://en.wikipedia.org/wiki/Comparison_of_object_database_management_systems

== db4o - Database 4(for) Objects ==

db4o és un exemple de les múltiples BBDD OO del mercat

http://www.db4o.com

Algunes de les seves característiques són:

*De codi obert sota llicència GPL, orientat a Java
*Senzill d'utilitzar i amb bon rendiment,
*La base de dades és un únic fitxer 
*Només cal importar una llibreria "db4o-8.0.....-all-java5.jar"



=== OME (Object Manager Enterprise) ===

El propi gestor incorpora una utilitat (Plugin per Eclipse) que permet explorar els objectes de la base de dades


[[ File: OME.png]]


Vista OME:

* db4o browser: mostra les classes i els atributs (Botó dret: View All Objects)
* Property View: Propietats de la BBDD, de les classes i dels objecte (OID), permet crear índexs
* Build Query: Crear consultes, arrossegant des del Browser
* Query Results: Mostrar resultat de les consultes i modificar valors

Menú OME

* Connectar i desconnectar de la Base de dades



'''Els exemples que es treballen a continuació són extrets de la documentació de db4o'''

=== Connectar i desconnectar ===

La connexió es molt simple, només cal indicar el fitxer.

Això genera un objecte ObjectContainer que representa la BBDD.

Per tancar la connexió es crida el mètode ''close()''.


<pre>
    private static final String BBDDFITXER = "DB4Oexemple";

    public static void main(String[] args) {
        new File(BBDDFITXER).delete(); // Obliga a crear nova BBDD cada vegada (Opcional)

        ObjectContainer db = Db4oEmbedded.openFile(Db4oEmbedded.newConfiguration(), BBDDFITXER);
        try {

            // Treballar amb la BBDD

        } finally {
            db.close();
        }
    }
</pre>


=== Classe Exemple Inicial ===

<pre>
public class Pilot {
    private String name;
    private int points;
    public Pilot(String name,int points) {
        this.name=name;
        this.points=points;
    }
    public int getPoints() {
        return points;
    }
    public void addPoints(int points) {
        this.points+=points;
    }
    public String getName() {
        return name;
    }
    public String toString() {
        return name+"/"+points;
    }
}
</pre>


=== Operacions ABM ===

La inserció i la modificació es realitzen a través del mètode ''store(object)''.

<pre>
// Desar objectes
            Pilot pilot1 = new Pilot("Michael Schumacher", 100);
            db.store(pilot1);

            Pilot pilot2 = new Pilot("Rubens Barrichello", 99);
            db.store(pilot2);
</pre>

Per modificar un objecte només cal cridar a ''store(object)'' després de fer els canvis

<pre>
            pilot1.addPoints(20);
            db.store(pilot1);
</pre>


La eliminació amb el mètode ''delete(object)'', més endavant veurem que aquí hi ha certes consideracions a tenir en compte.

<pre>
            db.delete(pilot2);
</pre>


=== Consultes ===


El gestor db4o permet tres tipus de consultes

* Query By Example (QBE).
* Native Queries (NQ). Opció recomanada, interface principal de consulta.
* SODA Query API.

==== Query By Example (QBE) ====

Es basa en crear un objecte propotip que s'utilitza d'exemple per a la consulta.

A partir del prototip s'obtenen els objectes que tenen els mateixos valors, per indicar "qualsevol" s'utilitzen els valors per defecte del tipus de l'atribut: 0 - enters, null - objectes, etc..

El resultat es retorna en un ObjectSet (Conjunt) que implementa les interfaces java.util.Collection<T>, java.lang.Iterable<T>, java.util.List<T>.

Es recomanable utilitzar alguna implementació com '''List'''

<pre>
            Pilot proto = new Pilot(null, 0);  // Tots
            List<Pilot> result = db.queryByExample(proto);
            System.out.println(result.size());
            for (Pilot p : result) {
                System.out.println(p);
            }
</pre>


<pre>
            proto = new Pilot("Michael Schumacher", 0);   // Pilots amb nom "Michael Schumacher"
            result = db.queryByExample(proto);
            System.out.println(result.size());
            Iterator<Pilot> it = result.iterator();
            while (it.hasNext()) {
                System.out.println(it.next());
            }

</pre>



==== Native Queries (NQ) ====

Aquesta és la opció recomanada a la documentació.

Els Inconvenients de QBE són:
* No es poden utilitzar expressions complexes AND, OR, NOT, >, <, == etc...
* No es poden posar condicions sobre els valors 0, null, etc... perquè s'interpreten com "qualsevol"
* Es necessari un constructor per a indicar les condicions sobre els atributs


Les consultes NQ:
* Permeten expressions complexes
* S'escriuen en el propi llenguatge (Java)
* Si es possible utilitzen els índexs definits


Les restriccions es creen a partir d'un predicat : '''Classe Abstracte Predicate'''

Aquesta classe només inclou el mètode abstracte '''match(candidat)''' que retorna l'expressió a avaluar sobre un objecte candidat


A l'exemple següent es mostra com fer una consulta amb '''anonymous inner classes''', en general això no és una bona pràctica perquè no permet reutilitzar codi i és poc clar. Tot i això hi ha situacions on és útil.


<pre>
            List <Pilot> pilots1 = db.query(new Predicate<Pilot>() {
                public boolean match(Pilot pilot) {
                    return pilot.getPoints() == 100;
                }
            });

</pre>


També es pot extendre la classe '''Predicate''' i sobreescriure el mètode '''match(candidate)'''

<pre>
            class PilotHundredPoints extends Predicate<Pilot> {
                public boolean match(Pilot pilot) {
                    return pilot.getPoints() == 100;
                }
            }

            List <Pilot> pilots2 = db.query(new PilotHundredPoints());
</pre>

A partir d'aquí es poden fer les consultes tant complexes com calgui

<pre>
            List <Pilot> pilots3 = db.query(new Predicate<Pilot>() {
                public boolean match(Pilot pilot) {
                    return pilot.getPoints() > 99
                            && pilot.getPoints() < 199
                            || pilot.getName().equals("Rubens Barrichello");
                }
            });
</pre>

==== Pas de paràmetres ====

Per passar paràmetres a les consultes utilitzant classes anònimes cal defini variables "final"

<pre>
            final int pts = 100;  // final: només es pot inicialitzar una vegada
            final int pts2;
            pts2 = 101;
            //pts2 = 102;
           
            List <Pilot> pilots1 = db.query(new Predicate<Pilot>() {
                public boolean match(Pilot pilot) {
                    return pilot.getPoints() == pts;
                }
            });
</pre>

Per a classes normals es pot afegir atributs i crear un contructor

<pre>

class PilotPuntsVariable extends Predicate<Pilot> {
    private int pts;
   
    public PilotPuntsVariable(int pts) {
        //super();
        this.pts = pts;
    }

    public boolean match(Pilot pilot) {
        return pilot.getPoints() == pts;
    }
}


List <Pilot> pilots2 = db.query(new PilotPuntsVariable(100));

</pre>

==== SODA Query API ====

SODA és l'API de baix nivell per a consultes. Per exemple internament les consultes NQ es transformen en SODA per optimitzar-les abans d'executar-les.

Utilitza strings per identificar els noms dels camps sobre els que posar restriccions

El gestor construeix un graf (arbre) de la consulta amb els nodes i les restriccions

* node --> Múltiples classes, una classe o un atribut d'una classe
* constrain --> Afegeix una restricció al node
* descend --> retorna un node descendent en el graf


<pre>
            // Tots els objectes
            Query query=db.query();  // Crea SODA query
            query.constrain(Pilot.class);    // Afegeix restricció
            List<Pilot> res = query.execute();

            // Tots els objectes amb un valor d'atribut concret
            Query query2=db.query();
            query2.constrain(Pilot.class);
            // Afegeix restricció sobre el node descendent (en aquest cas un atribut de tipus primitiu)
            query2.descend("name").constrain("Michael Schumacher");
            List<Pilot> res2=query2.execute();
</pre>


També permet afegir tot tipus de restriccions: AND, OR, NOT, etc...

<pre>
            // Negació
            query.descend("name").constrain("Michael Schumacher").not();

            // AND
            query.constrain(Pilot.class);
            Constraint constr=query.descend("name").constrain("Michael Schumacher");
            query.descend("points").constrain(99).and(constr);

            // OR
            query.descend("points").constrain(99).or(constr);

            // Més greater, equal, endsWith ...

            query.descend("points").constrain(99).greater();
</pre>


Alhora que ordenar el resultat

<pre>
            // Ordre dels resultats
            query.descend("name").orderAscending();
            query.descend("name").orderDescending();
</pre>

=== Associacions ===

Què passa quan tenim objectes associats? com es gestiona?


Afegim la següent classe als exemples

<pre>
public class Car {
    private String model;
    private Pilot pilot;
    private List<SensorReadout> history;
    public Car(String model) {
        this(model,new ArrayList<SensorReadout>());
    }
    public Car(String model,List<SensorReadout> history) {
        this.model=model;
        this.pilot=null;
        this.history=history;
    }
    public Pilot getPilot() {
        return pilot;
    }
    public void setPilot(Pilot pilot) {
        this.pilot=pilot;
    }
    public String getModel() {
        return model;
    }
    public List<SensorReadout> getHistory() {
        return history;
    }
   
    public void snapshot() {
        history.add(new SensorReadout(poll(),new Date(),this));
    }
   
    protected double[] poll() {
        int factor=history.size()+1;
        return new double[]{0.1d*factor,0.2d*factor,0.3d*factor};
    }
   
    public String toString() {
        return model+"["+pilot+"]/"+history.size()+" -> " + history.toString();
    }
}
</pre>


Les insercions funcionen igual.

Si es desen objectes, implícitament també es desen els objectes associats.

<pre>
            Car car1 = new Car("Ferrari");
            Pilot pilot3 = new Pilot("Michael Schumacher", 100);
            car1.setPilot(pilot3);
            db.store(car1);        // Desa també el pilot
</pre>


Les consultes també es treballen de la mateixa forma

<pre>
            final String pilotName = "Rubens Barrichello";
            List<Car> results = db.query(new Predicate<Car>() {
                public boolean match(Car car) {
                    return car.getPilot().getName().equals(pilotName);
                }
            });
</pre>

És interessant veure que es poden posar restriccions navegant d'un objecte a un altre associat, p.e. del cat --> pilot

Pregunta 1. Què passa si un cotxe no té pilot?

Amb el següent exemple es pot veure que que dins del mètode es genera una excepció si un cotxe no té pilot, però aquesta excepció la controla internament el gestor i no arriba a l'usuari.

El resultat simplement és que el candidat en qüestió no s'inclou en el resultat de la consulta.

<pre>
        Car car1 = new Car("Ferrari");
        //car1.setPilot(pilot);
        db.store(car1);

        List<Car> cars = db.query(new Predicate<Car>() {
            public boolean match(Car car) {
                boolean res = false;
               
                try {
                    res = car.getPilot().getName().equals("Rubens Barrichello");
                } catch (Exception e) {
                    System.out.println("-Excepcio-");
                }
                return res;
            }
        });
</pre>


Pregunta 2. Consulta per obtenir els cotxes sense Pilot



==== Modificacions.  Profunditat ====


Per gestionar la persistència d'objectes existents a la base de dades, cal indicar a db4o un paràmetre anomenat profunditat (depth).

Per defecte la profunditat és 1, això vol dir que es desa l'objecte i les seves dades primitives, però no els objectes associats.

Per contra és pot establir la profunditat fins a tot el sistema indicat el paràmetre '''cascadeOnUpdate(true)'''. Evidentment penalitzant en el rendiment del programa.

<pre>
        EmbeddedConfiguration config = Db4oEmbedded.newConfiguration();
        config.common().objectClass(Car.class).cascadeOnUpdate(true);
        ObjectContainer db = Db4oEmbedded.openFile(config, BBDDFITXER);
</pre>


==== Eliminacions. Recursivitat ====

De manera similar a les modificacions, les eliminacions no afectes als objectes associats en la configuració per defecte (p.e. Esborrar un cotxe no esborra el Pilot)

Però es pot establir que per una classe s'esborrin tots els objectes associats indicat el paràmetre '''cascadeOnDelete(true)'''

<pre>
        EmbeddedConfiguration config = Db4oEmbedded.newConfiguration();
        config.common().objectClass(Car.class).cascadeOnDelete(true);
        ObjectContainer db = Db4oEmbedded.openFile(config, BBDDFITXER);
</pre>


Cal vigilar en tot cas perquè db4o no valida si els objectes que s'esborren estan referenciats per altres objectes del sistema,

<pre>
        EmbeddedConfiguration config = Db4oEmbedded.newConfiguration();
        config.common().objectClass(Car.class).cascadeOnDelete(true);
        ObjectContainer db = Db4oEmbedded.openFile(config, BBDDFITXER);

        // Esborra tot
        List result=db.queryByExample(new Object());
        while(result.hasNext()) {
            db.delete(result.next());
        }

        Pilot pilot = new Pilot("Michael Schumacher", 100);
        Car car1 = new Car("Ferrari");
        Car car2 = new Car("BMW");
        car1.setPilot(pilot);
        car2.setPilot(pilot);
        db.store(car1);
        db.store(car2);
        db.delete(car2);

        List<Car> cars = db.query(new Predicate<Car>() {
            public boolean match(Car car) {
                return true;
            }
        });
       
        for (Car c : cars) {
            System.out.println(c);  // Mostra el cotxe car1
        }
        // Mostra Ferrari[Michael Schumacher/100] pq encara està a memòria
       
        db.close();
       
        db = Db4oEmbedded.openFile(Db4oEmbedded.newConfiguration(), BBDDFITXER);
       
        cars = db.query(new Predicate<Car>() {
            public boolean match(Car car) {
                return true;
            }
        });
       
        for (Car c : cars) {
            System.out.println(c); 
        }
        // Mostra Ferrari[null] el pilot s'havia esborrat
       
        db.close();
</pre>

=== Col·leccions ===


Per a les classes d'exemple utilitzarem un sensor genèric que afegirem al cotxe, i 3 sensors concrets: de temperatura, aigua i pressió.

Aquests sensor representa que prenen mesures en un moment concret. El cotxe té un historial de mesures, i té un mètode ''snapshot()'' que pren algunes mesures en un moment donat a través d'aquests sensors.

<pre>
public class SensorReadout {
    private double[] values;
    private Date time;
    private Car car;
    public SensorReadout(double[] values,Date time,Car car) {
        this.values=values;
        this.time=time;
        this.car=car;
    }
    public Car getCar() {
        return car;
    }
    public Date getTime() {
        return time;
    }
    public int getNumValues() {
        return values.length;
    }
    
    public double[] getValues(){
        return values;
    }
    
    public double getValue(int idx) {
        return values[idx];
    }
    public String toString() {
        StringBuffer str=new StringBuffer();
        str.append(car.getModel())
             .append(" : ")
            .append(time.getTime())
            .append(" : ");
       
        for(int idx=0;idx<values.length;idx++) {
            if(idx>0) {
                str.append(',');
            }
            str.append(values[idx]);
        }
        return str.toString();
    }}
</pre>


==== Emmagatzematge i eliminació ====

Segueix sent molt simple. La herència no aporta res a destacar.

Per exemple per emmagatzemar un objecte que conté una llista d'objectes que pertanyen a una jerarquia d'herència,


<pre>
        // Un cotxe amb vàries medicions de diferents tipus
        Pilot pilot2=new Pilot("Rubens Barrichello",99);
        Car car2=new Car("BMW");
        car2.setPilot(pilot2);
        car2.snapshot();
        car2.snapshot();
        db.store(car2);
</pre>

==== Consulta Col·lecció QBE ====

Tots els sensors amb qualsevol mesures
<pre>
        SensorReadout proto=new SensorReadout(null,null,null);
        List<SensorReadout> sensors=db.queryByExample(proto);
        for (SensorReadout c : sensors) {
            System.out.println(c); 
        }

        /*Resultats
        2
        BMW : 1393582541679 : 0.1,0.2,0.3
        BMW : 1393582541679 : 0.2,0.4,0.6       
        */

</pre>


Consulta amb prototip, valors desordenats no afecten, compara cada  element del prototip amb tots els elements dels objectes cercats
<pre>
SensorReadout proto = new SensorReadout(new double[] { 0.3, 0.1, 0.2 },
        null, null);
List<SensorReadout> results = db.queryByExample(proto);
listResult(results);
</pre>


Sensors amb unes  mesures concretes. Tot i que el vector de mesures té mida 3 i el prototip 2, cerca que existeixin TOTS (AND) els valors individuals del prototip
<pre>
SensorReadout proto = new SensorReadout(new double[] { 0.3, 0.1 },
        null, null);
List<SensorReadout> results = db.queryByExample(proto);
listResult(results);
</pre>

La següent consulta no troba res
<pre>
SensorReadout proto = new SensorReadout(new double[] { 0.4, 0.1 },
        null, null);
List<SensorReadout> results = db.queryByExample(proto);
listResult(results);
</pre>

En canvi aquesta si
<pre>
SensorReadout proto = new SensorReadout(new double[] { 0.3, 0.3, 0.1, 0.2 },
        null, null);
List<SensorReadout> results = db.queryByExample(proto);
listResult(results);
</pre>


Pregunta 1. Es pot consultar si alguna mesura té 2 valors iguals?

Pregunta 2. Es poden diferenciar les següents mesures : { 0.3, 0.1, 0.2 } i { 0.1, 0.3, 0.2 } ?

Pregunta 3. Es pot consultar si alguna mesura té 2  el valor 0.3 o 0.4 ?


Cotxes amb un historial de mesures concret
<pre>
SensorReadout protoreadout = new SensorReadout(new double[] { 0.6, 0.4 }, null, null);
List<SensorReadout> protohistory = new ArrayList<SensorReadout>();
protohistory.add(protoreadout);
Car protocar = new Car(null, protohistory);
List<Car> result = db.queryByExample(protocar);
listResult(result);
</pre>


Pregunta 4. Consulta QBE per obtenir els cotxes que condueix "Rubens Barrichello"

Pregunta 5. Consulta QBE per obtenir els cotxes que tenen una mesura que tingui {0.1} i una altra mesura que tingui {0.4}

==== Consulta Col·lecció NQ ====

Sensors amb alguna mesura concreta
<pre>
List<SensorReadout> results = db.query(new Predicate<SensorReadout>() {
      public boolean match(SensorReadout candidate) {
      /* Per usar Arrays.binarySearch el vector ha d'estar ordenat */
           return Arrays.binarySearch(candidate.getValues(), 0.3) >= 0
                   && Arrays.binarySearch(candidate.getValues(), 0.1) >= 0;
      }
});
listResult(results);
</pre>

http://docs.oracle.com/javase/7/docs/api/java/util/Arrays.html#binarySearch%28double[],%20double%29

Pregunta 1. Consulta per obtenir les mesures que tenen el valor 0.2 dues o més vegades

Pregunta 2. Consulta per obtenir les mesures que que tenen una mitjana superior a 3


Cotxes amb sensors que tinguin alguna mesura concreta
<pre>
List<Car> results = db.query(new Predicate<Car>() {
    public boolean match(Car candidate) {
        List history = candidate.getHistory();
        for (Object aHistory : history) {
            SensorReadout readout = (SensorReadout) aHistory;
            if (Arrays.binarySearch(readout.getValues(), 0.6) >= 0
                    || Arrays.binarySearch(readout.getValues(), 0.2) >= 0)
                return true;
        }
        return false;
    }
});
listResult(results);
</pre>


Pregunta 3. Consulta per obtenir els cotxes que tinguin alguna mesura, conduïts per "Rubens Barrichello" o que no tenen pilot

==== Consulta Col·lecció Soda ====

Sensors amb uns valors concrets
<pre>
            Query query = db.query();
            query.constrain(SensorReadout.class);
            Query valuequery = query.descend("values");  // valuequery és la col·lecció
            valuequery.constrain(0.3);
            valuequery.constrain(0.1);
            List<SensorReadout> result = query.execute();
            consultaSensorReadout(result);
</pre>


Sensors amb els valors 0.3 o 0.4
<pre>
            Query query = db.query();
            query.constrain(SensorReadout.class);
            Query valuequery = query.descend("values");  // valuequery és la col·lecció
            valuequery.constrain(0.3).or(valuequery.constrain(0.4));
            List<SensorReadout> result = query.execute();
            consultaSensorReadout(result);
</pre>


Pregunta 1. Obtenir els sensors que tenen alguna mesura major o igual a 0.3


Cotxe amb un historial amb un valors concrets
<pre>
             Query query = db.query();
             query.constrain(Car.class);
             Query historyquery = query.descend("history");
             // historyquery.constrain(SensorReadout.class);  // No cal
             Query valuequery = historyquery.descend("values");
             valuequery.constrain(0.3);
             valuequery.constrain(0.1);
             ObjectSet result = query.execute();
             listResult(result);
</pre>


Pregunta 2. Obtenir els cotxes amb historial que tinguin els valors 0.1, 0.2 o 0.6



En general és pot ampliar l'API de SODA implementant Evaluation
Evaluation és una interfície que té el mètode evaluate(Candidate candidate)
Dins el mètode cal afegir les condicions per incloure el candidat

<pre>
class CountHistoryEvaluation implements Evaluation {
    /* Cotxes amb 2 o més historials */
    public void evaluate(Candidate candidate) {
        Car car=(Car)candidate.getObject();
        candidate.include(car.getHistory().size() >= 2);  /* Condició per incloure candidat */

    }
}

            Query query = db.query();
            query.constrain(Car.class);
            query.constrain(new CountHistoryEvaluation());           
            List<Car> result = query.execute();
            consultaCar(result);

</pre>


Pregunta 3. Crear una implementació d'Evaluation per consultar els cotxes que tenen alguna de les mesures repetides. Fer la consulta

Pregunta 4. Crear una implementació d'Evaluation per consultar els cotxes que tenen alguna de les mesures indicades en un vector double[] qualsevol. Fer la consulta pel vector {0.2, 0.7}