Android
GreenDAO

Invoering

Hulpmethoden voor SELECT-, INSERT-, DELETE-, UPDATE-zoekopdrachten

Dit voorbeeld toont een helperklasse die nuttige methoden bevat bij het uitvoeren van de query's voor gegevens. Elke methode hier gebruikt Java Generic's om zeer flexibel te zijn.

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

Een entiteit maken met GreenDAO 3.X met een samengestelde primaire sleutel

Bij het maken van een model voor een tabel met een samengestelde primaire sleutel is extra werk vereist aan het object zodat de modelentiteit deze beperkingen kan respecteren.

Het volgende voorbeeld van SQL-tabel en entiteit toont de structuur voor het opslaan van een beoordeling achtergelaten door een klant voor een artikel in een online winkel. In dit voorbeeld willen we dat de kolommen customer_id en item_id een samengestelde primaire sleutel zijn, waardoor er slechts één review bestaat tussen een specifieke klant en een item.

SQL-tabel

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

Meestal gebruiken we de annotaties @Id en @Unique boven de respectieve velden in de entiteitsklasse, maar voor een samengestelde primaire sleutel doen we het volgende:

1. Voeg de annotatie @Index binnen de annotatie op klasse niveau @Entity . De eigenschap value bevat een door komma's gescheiden lijst van de velden waaruit de sleutel bestaat. Gebruik de unique eigenschap zoals getoond om uniekheid op de sleutel af te dwingen.

2. GreenDAO vereist dat elke entiteit een long of Long object als primaire sleutel heeft. We moeten dit nog steeds toevoegen aan de klasse Entity, maar we hoeven het niet te gebruiken of ons zorgen te maken dat het onze implementatie beïnvloedt. In het onderstaande voorbeeld wordt het localID

Entiteit

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

Aan de slag met Greenatri v3.X

Nadat we de afhankelijkheid van de Greenbd-bibliotheek en de Gradle-plug-in hebben toegevoegd, moeten we eerst een entiteitsobject maken.

Entiteit

Een entiteit is een gewoon oud Java-object (POJO) dat sommige gegevens in de database modelleert. Greenatri zal deze klasse gebruiken om een tabel in de SQLite-database te maken en automatisch helperklassen genereren die we kunnen gebruiken om gegevens te openen en op te slaan zonder SQL-instructies te hoeven schrijven.

@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...

}

Eenmalige installatie van Greenatri

Telkens wanneer een toepassing wordt gestart, moet Greenatri worden geïnitialiseerd. Greenatri stelt voor om deze code in een toepassingsklasse te bewaren of ergens waar deze slechts één keer wordt uitgevoerd.

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

Greenoede Helper Classes

Nadat het entiteitsobject is gemaakt, maakt Greenatri automatisch de helperklassen die worden gebruikt om te communiceren met de database. Deze worden op dezelfde manier genoemd als de naam van het entiteitsobject dat is gemaakt, gevolgd door Dao en worden opgehaald uit het daoSession object.

UsersDao usersDao = daoSession.getUsersDao();

Veel typische database-acties kunnen nu worden uitgevoerd met behulp van dit Dao-object met het entiteitsobject.

vraag

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

invoegen

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

Bijwerken

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

Delete

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