Android
GreenDAO

Wprowadzenie

Metody pomocnicze dla zapytań SELECT, INSERT, DELETE, UPDATE

Ten przykład pokazuje klasę pomocnika, która zawiera metody przydatne podczas wykonywania zapytań o dane. Każda metoda tutaj używa Java Generic's, aby być bardzo elastycznym.

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

Tworzenie jednostki za pomocą GreenDAO 3.X, która ma złożony klucz podstawowy

Podczas tworzenia modelu dla tabeli ze złożonym kluczem podstawowym wymagana jest dodatkowa praca na obiekcie, aby jednostka modelu mogła przestrzegać tych ograniczeń.

W poniższej przykładowej tabeli SQL i encji pokazano strukturę do przechowywania recenzji pozostawionej przez klienta dla elementu w sklepie internetowym. W tym przykładzie chcemy, aby kolumny customer_id i item_id były złożonym kluczem podstawowym, umożliwiając istnienie tylko jednej recenzji między określonym klientem a produktem.

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

Zazwyczaj będziemy używać @Id i @Unique adnotacji powyżej odpowiednich pól w klasie encji, jednak dla złożonego klucza podstawowego możemy wykonać następujące czynności:

1. Dodaj adnotację @Index adnotacji @Index na poziomie @Entity . Właściwość value zawiera rozdzielaną przecinkami listę pól, które składają się na klucz. Użyj unique właściwości, jak pokazano, aby wymusić unikalność klucza.

2. GreenDAO wymaga, aby każda jednostka miała long lub Long obiekt jako klucz podstawowy. Nadal musimy dodać to do klasy Entity, jednak nie musimy go używać ani martwić się, że wpłynie to na naszą implementację. W poniższym przykładzie nazywa się localID

Jednostka

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

Rozpoczęcie pracy z Greenimedem v3.X

Po dodaniu zależności biblioteki Greenda i wtyczki Gradle musimy najpierw utworzyć obiekt encji.

Jednostka

Obiekt to zwykły stary obiekt Java (POJO), który modeluje niektóre dane w bazie danych. Greenda użyje tej klasy do utworzenia tabeli w bazie danych SQLite i automatycznie wygeneruje klasy pomocnicze, których możemy użyć do uzyskania dostępu i przechowywania danych bez konieczności pisania instrukcji 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...

}

Jednorazowa konfiguracja Greenexe

Za każdym razem, gdy aplikacja jest uruchamiana, należy inicjować Greenda. Greenda sugeruje zachowanie tego kodu w klasie aplikacji lub w innym miejscu, który zostanie uruchomiony tylko raz.

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

Klasy pomocników Greendao

Po utworzeniu obiektu encji Greenda automatycznie tworzy klasy pomocnicze używane do interakcji z bazą danych. Są one nazywane podobnie do nazwy obiektu encji, który został utworzony, a następnie Dao i są pobierane z obiektu daoSession .

UsersDao usersDao = daoSession.getUsersDao();

Można teraz wykonać wiele typowych akcji bazy danych przy użyciu tego obiektu Dao z obiektem encji.

Pytanie

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

Wstawić

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

Aktualizacja

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

Usunąć

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