Android
GreenDAO

Introducción

Métodos de ayuda para las consultas SELECT, INSERT, DELETE, UPDATE

Este ejemplo muestra una clase auxiliar que contiene métodos útiles cuando se ejecutan las consultas de datos. Cada método aquí utiliza Java Genérico para ser muy flexible.

public <T> List<T> selectElements(AbstractDao<T, ?> dao) {
    if (dao == null) {
        return null;
    }
    QueryBuilder<T> qb = dao.queryBuilder();
    return qb.list();
}

public <T> void insertElements(AbstractDao<T, ?> absDao, List<T> items) {
    if (items == null || items.size() == 0 || absDao == null) {
        return;
    }
    absDao.insertOrReplaceInTx(items);
}

public <T> T insertElement(AbstractDao<T, ?> absDao, T item) {
    if (item == null || absDao == null) {
        return null;
    }
    absDao.insertOrReplaceInTx(item);
    return item;
}

public <T> void updateElements(AbstractDao<T, ?> absDao, List<T> items) {
    if (items == null || items.size() == 0 || absDao == null) {
        return;
    }
    absDao.updateInTx(items);
}

public <T> T selectElementByCondition(AbstractDao<T, ?> absDao,
                                      WhereCondition... conditions) {
    if (absDao == null) {
        return null;
    }
    QueryBuilder<T> qb = absDao.queryBuilder();
    for (WhereCondition condition : conditions) {
        qb = qb.where(condition);
    }
    List<T> items = qb.list();
    return items != null && items.size() > 0 ? items.get(0) : null;
}

public <T> List<T> selectElementsByCondition(AbstractDao<T, ?> absDao,
                                             WhereCondition... conditions) {
    if (absDao == null) {
        return null;
    }
    QueryBuilder<T> qb = absDao.queryBuilder();
    for (WhereCondition condition : conditions) {
        qb = qb.where(condition);
    }
    List<T> items = qb.list();
    return items != null ? items : null;
}

public <T> List<T> selectElementsByConditionAndSort(AbstractDao<T, ?> absDao,
                                                    Property sortProperty,
                                                    String sortStrategy,
                                                    WhereCondition... conditions) {
    if (absDao == null) {
        return null;
    }
    QueryBuilder<T> qb = absDao.queryBuilder();
    for (WhereCondition condition : conditions) {
        qb = qb.where(condition);
    }
    qb.orderCustom(sortProperty, sortStrategy);
    List<T> items = qb.list();
    return items != null ? items : null;
}

public <T> List<T> selectElementsByConditionAndSortWithNullHandling(AbstractDao<T, ?> absDao,
                                                                    Property sortProperty,
                                                                    boolean handleNulls,
                                                                    String sortStrategy,
                                                                    WhereCondition... conditions) {
    if (!handleNulls) {
        return selectElementsByConditionAndSort(absDao, sortProperty, sortStrategy, conditions);
    }
    if (absDao == null) {
        return null;
    }
    QueryBuilder<T> qb = absDao.queryBuilder();
    for (WhereCondition condition : conditions) {
        qb = qb.where(condition);
    }
    qb.orderRaw("(CASE WHEN " + "T." + sortProperty.columnName + " IS NULL then 1 ELSE 0 END)," + "T." + sortProperty.columnName + " " + sortStrategy);
    List<T> items = qb.list();
    return items != null ? items : null;
}

public <T, V extends Class> List<T> selectByJoin(AbstractDao<T, ?> absDao,
                                                 V className,
                                                 Property property, WhereCondition whereCondition) {
    QueryBuilder<T> qb = absDao.queryBuilder();
    qb.join(className, property).where(whereCondition);
    return qb.list();
}

public <T> void deleteElementsByCondition(AbstractDao<T, ?> absDao,
                                          WhereCondition... conditions) {
    if (absDao == null) {
        return;
    }
    QueryBuilder<T> qb = absDao.queryBuilder();
    for (WhereCondition condition : conditions) {
        qb = qb.where(condition);
    }
    List<T> list = qb.list();
    absDao.deleteInTx(list);
}

public <T> T deleteElement(DaoSession session, AbstractDao<T, ?> absDao, T object) {
    if (absDao == null) {
        return null;
    }
    absDao.delete(object);
    session.clear();
    return object;
}

public <T, V extends Class> void deleteByJoin(AbstractDao<T, ?> absDao,
                                              V className,
                                              Property property, WhereCondition whereCondition) {
    QueryBuilder<T> qb = absDao.queryBuilder();
    qb.join(className, property).where(whereCondition);
    qb.buildDelete().executeDeleteWithoutDetachingEntities();
}

public <T> void deleteAllFromTable(AbstractDao<T, ?> absDao) {
    if (absDao == null) {
        return;
    }
    absDao.deleteAll();
}

public <T> long countElements(AbstractDao<T, ?> absDao) {
    if (absDao == null) {
        return 0;
    }
    return absDao.count();
}

Creación de una entidad con GreenDAO 3.X que tiene una clave primaria compuesta

Al crear un modelo para una tabla que tiene una clave primaria compuesta, se requiere trabajo adicional en el Objeto para que la Entidad modelo respete esas restricciones.

La siguiente tabla SQL de ejemplo y Entidad muestra la estructura para almacenar una revisión dejada por un cliente para un artículo en una tienda en línea. En este ejemplo, queremos que las columnas customer_id y item_id sean una clave primaria compuesta, permitiendo que solo exista una revisión entre un cliente específico y un artículo.

Tabla SQL

CREATE TABLE review (
    customer_id STRING NOT NULL,
    item_id STRING NOT NULL,
    star_rating INTEGER NOT NULL,
    content STRING,
    PRIMARY KEY (customer_id, item_id)
);

Por lo general, @Unique anotaciones @Id y @Unique sobre los campos respectivos en la clase de entidad, sin embargo, para una clave primaria compuesta hacemos lo siguiente:

1. Agregue la anotación @Index dentro de la anotación @Entity nivel de @Entity . La propiedad de valor contiene una lista delimitada por comas de los campos que conforman la clave. Use la propiedad unique como se muestra para imponer la singularidad en la clave.

2. GreenDAO requiere que cada Entidad tenga un objeto long o Long como clave principal. Aún necesitamos agregar esto a la clase Entidad, sin embargo, no necesitamos usarlo o preocuparnos de que esto afecte nuestra implementación. En el siguiente ejemplo se llama localID

Entidad

@Entity(indexes = { @Index(value = "customer_id,item_id", unique = true)})
public class Review {

    @Id(autoincrement = true)
    private Long localID;

    private String customer_id;
    private String item_id;

    @NotNull
    private Integer star_rating;

    private String content;

    public Review() {}
}

Empezando con GreenDao v3.X

Después de agregar la dependencia de la biblioteca GreenDao y el complemento Gradle, primero debemos crear un objeto de entidad.

Entidad

Una entidad es un objeto Java antiguo simple (POJO) que modela algunos datos en la base de datos. GreenDao usará esta clase para crear una tabla en la base de datos SQLite y generar automáticamente las clases auxiliares que podemos usar para acceder y almacenar datos sin tener que escribir sentencias de SQL.

@Entity
public class Users {

    @Id(autoincrement = true)
    private Long id;

    private String firstname;
    private String lastname;

    @Unique
    private String email;

    // Getters and setters for the fields...

}

Una sola vez configuración de GreenDao

Cada vez que se lanza una aplicación, GreenDao necesita ser inicializada. GreenDao sugiere mantener este código en una clase de aplicación o en algún lugar que solo se ejecutará una vez.

DaoMaster.DevOpenHelper helper = new DaoMaster.DevOpenHelper(this, "mydatabase", null);
db = helper.getWritableDatabase();
DaoMaster daoMaster = new DaoMaster(db);
DaoSession daoSession = daoMaster.newSession();

Clases de ayuda de GreenDao

Después de que se crea el objeto de entidad, GreenDao crea automáticamente las clases auxiliares utilizadas para interactuar con la base de datos. Estos se denominan de forma similar al nombre del objeto de entidad que se creó, seguido de Dao y se recuperan del objeto daoSession .

UsersDao usersDao = daoSession.getUsersDao();

Muchas acciones típicas de la base de datos ahora se pueden realizar usando este objeto Dao con el objeto entidad.

Consulta

String email = "[email protected]";
String firstname = "John";

// Single user query WHERE email matches "[email protected]"
Users user = userDao.queryBuilder()
                .where(UsersDao.Properties.Email.eq(email)).build().unique();

// Multiple user query WHERE firstname = "John"
List<Users> user = userDao.queryBuilder()
                .where(UsersDao.Properties.Firstname.eq(firstname)).build().list();

Insertar

Users newUser = new User("John","Doe","[email protected]");
usersDao.insert(newUser);

Actualizar

// Modify a previously retrieved user object and update
user.setLastname("Dole");
usersDao.update(user);

Borrar

// Delete a previously retrieved user object
usersDao.delete(user);