Android
GreenDAO

Introduktion

Hjälpmetoder för VÄLJ, INSERT, DELETE, UPDATE frågor

Det här exemplet visar en hjälparklass som innehåller användbara metoder när du kör frågorna för data. Varje metod här använder Java Generic för att vara mycket flexibel.

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

Skapa en enhet med GreenDAO 3.X som har en sammansatt primärnyckel

När du skapar en modell för en tabell som har en sammansatt primärnyckel krävs ytterligare arbete i objektet för modellen Enhet för att respektera dessa begränsningar.

Följande exempel SQL-tabell och enhet visar strukturen för att lagra en recension som lämnas av en kund för ett objekt i en onlinebutik. I det här exemplet vill vi att kolumnerna customer_id och item_id ska vara en sammansatt primärnyckel, så att endast en recension kan existera mellan en specifik kund och ett objekt.

SQL-tabell

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

Vanligtvis använder @Id @Unique @Id och @Unique kommentarerna över respektive fält i entitetsklassen, men för en sammansatt primärnyckel gör vi följande:

1. Lägg till @Index kommentaren i @Entity kommentaren. Värdegenskapen innehåller en kommaavgränsad lista över fälten som utgör nyckeln. Använd den unique egenskapen som visas för att säkerställa unikhet på nyckeln.

2. GreenDAO kräver att varje enhet har ett long eller Long objekt som en primär nyckel. Vi måste fortfarande lägga till detta i entitetsklassen, men vi behöver inte använda det eller oroa oss för att det påverkar vårt genomförande. I exemplet nedan kallas det localID

Entitet

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

Komma igång med GreenDao v3.X

Efter att ha lagt till GreenDao-bibliotekets beroende och Gradle-plugin måste vi först skapa ett enhetsobjekt.

Entitet

En enhet är ett vanligt Java-objekt (POJO) som modellerar en del data i databasen. GreenDao kommer att använda den här klassen för att skapa en tabell i SQLite-databasen och generera automatiskt hjälpklasser som vi kan använda för att komma åt och lagra data utan att behöva skriva SQL-satser.

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

}

Engångsinstallation av GreenDao

Varje gång en applikation lanseras måste GreenDao initieras. GreenDao föreslår att du behåller den här koden i en applikationsklass eller någon annanstans kommer den att köras en gång.

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

GreenDao Helper Classes

När entitetsobjektet har skapats skapar GreenDao automatiskt hjälparklasserna som används för att interagera med databasen. Dessa namnges på samma sätt som namnet på enhetsobjektet som skapades, följt av Dao och hämtas från daoSession objektet.

UsersDao usersDao = daoSession.getUsersDao();

Många typiska databasåtgärder kan nu utföras med hjälp av detta Dao-objekt med entitetsobjektet.

Fråga

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

Föra in

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

Uppdatering

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

Radera

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