Android
GreenDAO

introduzione

Metodi di supporto per le query SELECT, INSERT, DELETE, UPDATE

Questo esempio mostra una classe helper che contiene metodi utili, quando si eseguono le query per i dati. Ogni metodo qui utilizza Java Generic per essere molto flessibile.

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

Creazione di un'entità con GreenDAO 3.X con una chiave primaria composta

Quando si crea un modello per una tabella con una chiave primaria composta, è necessario un lavoro aggiuntivo sull'oggetto per consentire al modello Entity di rispettare tali vincoli.

Il seguente esempio di tabella SQL ed entità mostra la struttura per memorizzare una recensione lasciata da un cliente per un articolo in un negozio online. In questo esempio, vogliamo che le colonne customer_id e item_id siano una chiave primaria composta, consentendo l'esistenza di una sola recensione tra un cliente e un articolo specifici.

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

Solitamente avremmo utilizzare i @Id e @Unique annotazioni sopra i rispettivi campi nella classe entità, tuttavia per una chiave primaria composta facciamo la seguente:

1. Aggiungi l'annotazione @Index all'interno dell'annotazione @Index a livello di @Entity . La proprietà value contiene un elenco delimitato da virgole dei campi che compongono la chiave. Utilizzare la proprietà unique come mostrato per far rispettare l'univocità sulla chiave.

2. GreenDAO richiede che ogni Entità abbia un oggetto long o Long come chiave primaria. Abbiamo ancora bisogno di aggiungere questo alla classe Entity, tuttavia non abbiamo bisogno di usarlo o preoccuparci di ciò che riguarda la nostra implementazione. Nell'esempio seguente è chiamato 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() {}
}

Iniziare con GreenDao v3.X

Dopo aver aggiunto la dipendenza della libreria GreenDao e il plugin Gradle, dobbiamo prima creare un oggetto entità.

Entità

Un'entità è un oggetto Plain Old Java (POJO) che modella alcuni dati nel database. GreenDao utilizzerà questa classe per creare una tabella nel database SQLite e generare automaticamente classi di supporto che è possibile utilizzare per accedere e archiviare i dati senza dover scrivere istruzioni 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...

}

Configurazione OneWay GreenDao

Ogni volta che viene lanciata un'applicazione, è necessario inizializzare la GreenDao. GreenDao suggerisce di mantenere questo codice in una classe Application o in qualche luogo verrà eseguito una sola volta.

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

Classi Helper di GreenDao

Dopo aver creato l'oggetto entità, GreenDao crea automaticamente le classi helper utilizzate per interagire con il database. Questi sono chiamati in modo simile al nome dell'oggetto entità che è stato creato, seguito da Dao e recuperati dall'oggetto daoSession .

UsersDao usersDao = daoSession.getUsersDao();

Molte azioni tipiche del database possono ora essere eseguite utilizzando questo oggetto Dao con l'oggetto entità.

domanda

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

Inserire

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

Aggiornare

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

Elimina

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