2. Primeros Pasos


Comencemos de la forma mas simple posible. Vamos a aprender como almacenar, recuperar, actualizar y borrar instancias de una única clase que solo contiene primitivas y cadena de caracteres. En nuestro ejemplo será un piloto de Formula Uno (F1) cuyos atributos son su nombre y los puntos que haya ganado esta temporada.

Primero creamos una clase nativa como:


package com.db4o.f1.chapter1;

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;
    }
}



Nótese que esta clase no contiene ningún tipo de código relacionado con db4o.


    2.1. Almacenando objetos


    Para crear o acceder a un archivo de base de datos db4o existente, llame Db4o.openFile(), pasando la ruta al archivo como parámetro; así obtenemos una instancia de ObjectContainer. ObjectContainer será su interfase primaria a db4o. Cerrando el contenedor se liberarán todos los recursos asociados al mismo.


    [accessDb4o]
    ObjectContainer db=Db4o.openFile(Util.YAPFILENAME);
    try {
        // do something with db4o
    }
    finally {
        db.close();
    }


    Para los siguientes ejemplos asumiremos que su ambiente se encarga de abrir y cerrar el ObjectContainer automagicamente.

    Para almacenar un object, simplemente llamamos set() sobre nuestra base de datos, pasando el objeto como parámetro.


    [storeFirstPilot]
    Pilot pilot1=new Pilot("Michael Schumacher",100);
    db.set(pilot1);
    System.out.println("Stored "+pilot1);


    También necesitaremos un segundo piloto.


    [storeSecondPilot]
    Pilot pilot2=new Pilot("Rubens Barrichello",99);
    db.set(pilot2);
    System.out.println("Stored "+pilot2);



    2.2. Recuperando objetos


    Para hacer una consulta por nuestro piloto, debemos usar Consulta por Ejemplo (Query by Example) (QBE) por ahora. Esto significa que vamos a crear un objeto prototípico para que db4o lo use como ejemplo. db4o va a recuperar todos los objetos del tipo dado que contengan los mismos valores (que no sean por defecto) que el candidato. El resultado va a ser manejado como una instancia de ObjectSet. Vamos a usar un método conveniente 'listResult', heredado por todas nuestras clases de ejemplo, para mostrar el contenido de un resultado y reiniciarlo para uso posterior:


    public static void listResult{
        System.out.println(result.size());
        while(result.hasNext()) {
            System.out.println(result.next());
        }
    }


    Para recuperar todos los pilotos de nuestra base de datos, proveemos un prototipo 'vacío':


    [retrieveAllPilots]
    Pilot proto=new Pilot(null,0);
    ObjectSet result=db.get(proto);
    listResult(result);


    Nótese que los resultados no están obligados a tener 0 puntos, sino que 0 es el valor por defecto de los campos int.

    Para hacer una consulta para un piloto por nombre:


    [retrievePilotByName]
    Pilot proto=new Pilot("Michael Schumacher",0);
    ObjectSet result=db.get(proto);
    listResult(result);


    Recuperemos un piloto por su cantidad exacta de puntos:


    [retrievePilotByExactPoints]
    Pilot proto=new Pilot(null,100);
    ObjectSet result=db.get(proto);
    listResult(result);


    Por supuesto hay mucho mas respecto a consultas db4o, como se verá en unos momentos.


    2.3. Actualizando objetos


    Para actualizar objetos ya almacenados en db4o, simplemente llamamos set() nuevamente antes de modificarlo.


    [updatePilot]
    ObjectSet result=db.get(new Pilot("Michael Schumacher",0));
    Pilot found=(Pilot)result.next();
    found.addPoints(11);
    db.set(found);
    System.out.println("Added 11 points for "+found);
    retrieveAllPilots(db);


    Nótese que es necesario que db4o 'conozca' de antemano el piloto en cuestión, de otra forma lo almacenará como un objeto nuevo. 'Conocer' un objeto básicamente significa haberlo seteado o recuperado durante la sesión db4o actual. Mas adelante vamos a explicar esto con mas detalle.

    Para asegurarse de que el piloto a sido actualizado, por favor vuelva a cualquiera de los ejemplos de recuperación anteriores y córralo nuevamente.


    2.4. Borrando objetos


    Para borrar objetos de la base de datos se usa el método delete().


    [deleteFirstPilotByName]
    ObjectSet result=db.get(new Pilot("Michael Schumacher",0));
    Pilot found=(Pilot)result.next();
    db.delete(found);
    System.out.println("Deleted "+found);
    retrieveAllPilots(db);


    Borremos el otro también.


    [deleteSecondPilotByName]
    ObjectSet result=db.get(new Pilot("Rubens Barrichello",0));
    Pilot found=(Pilot)result.next();
    db.delete(found);
    System.out.println("Deleted "+found);
    retrieveAllPilots(db);


    Por favor compruebe la eliminación con los ejemplos de recuperación de mas arriba.

    Una vez mas, el objeto a borrar debe ser conocido por db4o. No es suficiente proveer un objeto prototipo con los mismo valores.


    2.5. Conclusión


    Eso fue fácil, no ? Hemos almacenado, recuperado, actualizado y borrado objetos con unas cuantas líneas de código. Pero que hay sobre consultas complejas ? Demosle una mirada a las restricciones de QBE y propuestas alternativas en el próximo capítulo .


    2.6. Fuente completo



    package com.db4o.f1.chapter1;


    import java.io.File;

    import com.db4o.Db4o;
    import com.db4o.ObjectContainer;
    import com.db4o.ObjectSet;
    import com.db4o.f1.Util;


    public class FirstStepsExample extends Util {    
        public static void main(String[] args) {
            new File(Util.YAPFILENAME).delete();
            accessDb4o();
            new File(Util.YAPFILENAME).delete();
            ObjectContainer db=Db4o.openFile(Util.YAPFILENAME);
            try {
                storeFirstPilot(db);
                storeSecondPilot(db);
                retrieveAllPilots(db);
                retrievePilotByName(db);
                retrievePilotByExactPoints(db);
                updatePilot(db);
                deleteFirstPilotByName(db);
                deleteSecondPilotByName(db);
            }
            finally {
                db.close();
            }
        }
        
        public static void accessDb4o() {
            ObjectContainer db=Db4o.openFile(Util.YAPFILENAME);
            try {
                // do something with db4o
            }
            finally {
                db.close();
            }
        }
        
        public static void storeFirstPilot(ObjectContainer db) {
            Pilot pilot1=new Pilot("Michael Schumacher",100);
            db.set(pilot1);
            System.out.println("Stored "+pilot1);
        }

        public static void storeSecondPilot(ObjectContainer db) {
            Pilot pilot2=new Pilot("Rubens Barrichello",99);
            db.set(pilot2);
            System.out.println("Stored "+pilot2);
        }

        public static void retrieveAllPilots(ObjectContainer db) {
            Pilot proto=new Pilot(null,0);
            ObjectSet result=db.get(proto);
            listResult(result);
        }

        public static void retrievePilotByName(ObjectContainer db) {
            Pilot proto=new Pilot("Michael Schumacher",0);
            ObjectSet result=db.get(proto);
            listResult(result);
        }
        
        public static void retrievePilotByExactPoints(ObjectContainer db) {
            Pilot proto=new Pilot(null,100);
            ObjectSet result=db.get(proto);
            listResult(result);
        }

        public static void updatePilot(ObjectContainer db) {
            ObjectSet result=db.get(new Pilot("Michael Schumacher",0));
            Pilot found=(Pilot)result.next();
            found.addPoints(11);
            db.set(found);
            System.out.println("Added 11 points for "+found);
            retrieveAllPilots(db);
        }

        public static void deleteFirstPilotByName(ObjectContainer db) {
            ObjectSet result=db.get(new Pilot("Michael Schumacher",0));
            Pilot found=(Pilot)result.next();
            db.delete(found);
            System.out.println("Deleted "+found);
            retrieveAllPilots(db);
        }

        public static void deleteSecondPilotByName(ObjectContainer db) {
            ObjectSet result=db.get(new Pilot("Rubens Barrichello",0));
            Pilot found=(Pilot)result.next();
            db.delete(found);
            System.out.println("Deleted "+found);
            retrieveAllPilots(db);
        }
    }





    --
    generated by
    Doctor courtesy of db4objecs Inc.