Android
GreenDAO

Introduction

Méthodes d'aide pour les requêtes SELECT, INSERT, DELETE, UPDATE

Cet exemple montre une classe d'assistance qui contient des méthodes utiles lors de l'exécution des requêtes pour les données. Chaque méthode utilise Java Generic afin d'être très 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();
}

Création d'une entité avec GreenDAO 3.X qui possède une clé primaire composite

Lors de la création d'un modèle pour une table dotée d'une clé primaire composite, un travail supplémentaire est requis sur l'objet pour que l'entité modèle respecte ces contraintes.

L'exemple suivant de table SQL et d'entité illustre la structure permettant de stocker une révision laissée par un client pour un élément dans un magasin en ligne. Dans cet exemple, nous voulons que les colonnes customer_id et item_id soient une clé primaire composite, ce qui ne permet qu'une seule révision entre un client et un article spécifiques.

Table 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)
);

Habituellement, nous utiliserions les annotations @Id et @Unique au-dessus des champs respectifs de la classe d'entités, mais pour une clé primaire composite, nous procédons comme suit:

1. Ajoutez l'annotation @Index à l'intérieur de l'annotation @Entity niveau de la classe. La propriété value contient une liste séparée par des virgules des champs qui constituent la clé. Utilisez la propriété unique comme indiqué pour appliquer l'unicité à la clé.

2. GreenDAO exige que chaque entité ait un objet long ou Long tant que clé primaire. Nous devons toujours ajouter ceci à la classe Entity, mais nous n'avons pas besoin de l'utiliser ou de nous en préoccuper pour notre implémentation. Dans l'exemple ci-dessous, il s'appelle localID

Entité

@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() {}
}

Démarrer avec GreenDao v3.X

Après avoir ajouté la dépendance à la bibliothèque GreenDao et le plug-in Gradle, vous devez d'abord créer un objet entité.

Entité

Une entité est un objet POJO ( Plain Old Java Object ) qui modélise certaines données dans la base de données. GreenDao utilisera cette classe pour créer une table dans la base de données SQLite et générer automatiquement des classes d'assistance que nous pouvons utiliser pour accéder et stocker des données sans avoir à écrire d'instructions 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...

}

Configuration unique de GreenDao

Chaque fois qu'une application est lancée, GreenDao doit être initialisé. GreenDao suggère de conserver ce code dans une classe Application ou quelque part il ne sera exécuté qu'une seule fois.

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

Classes d'assistance GreenDao

Une fois l'objet entité créé, GreenDao crée automatiquement les classes d'assistance utilisées pour interagir avec la base de données. Celles-ci sont nommées de la même manière que le nom de l'objet entité créé, suivi de Dao et récupérées à partir de l'objet daoSession .

UsersDao usersDao = daoSession.getUsersDao();

De nombreuses actions de base de données typiques peuvent maintenant être effectuées à l'aide de cet objet Dao avec l'objet entité.

Question

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();

Insérer

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

Mettre à jour

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

Effacer

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