Android
GreenDAO

소개

SELECT, INSERT, DELETE, UPDATE 쿼리에 대한 도우미 메서드

이 예제는 데이터에 대한 쿼리를 실행할 때 유용한 메서드가 포함 된 도우미 클래스를 보여줍니다. 여기있는 모든 메소드는 매우 융통성있게 Java Generic을 사용합니다.

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

복합 기본 키가있는 GreenDAO 3.X로 엔티티 만들기

복합 기본 키가있는 테이블에 대한 모델을 만들 때 모델 엔터티가 해당 제약 조건을 존중하도록 Object에 대한 추가 작업이 필요합니다.

다음 예제 SQL 테이블 및 엔티티는 고객이 온라인 상점에 항목에 대해 남긴 검토를 저장하는 구조를 보여줍니다. 이 예에서는 customer_id 및 item_id 열을 복합 기본 키로 지정하여 특정 고객과 항목간에 하나의 검토 만 허용합니다.

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

보통 엔티티 클래스의 각 필드 위에 @Id 및 @Unique 주석을 사용하지만 복합 기본 키의 경우 다음을 수행합니다.

1. @Index 어노테이션을 클래스 수준의 @Entity 어노테이션 안에 추가하십시오. value 속성은 키를 구성하는 쉼표로 구분 된 필드 목록을 포함합니다. 키에 고유성을 적용하려면 표시된대로 unique 속성을 사용하십시오.

2. GreenDAO는 모든 엔티티가 long 또는 Long 객체를 기본 키로 가질 것을 요구합니다. 우리는 이것을 Entity 클래스에 추가해야하지만, 우리는 그것을 사용할 필요가 없으며, 구현에 영향을 미치지 않도록 걱정할 필요가 있습니다. 아래 예제에서는 localID 라고합니다.

실재

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

GreenDao v3.X 시작하기

GreenDao 라이브러리 의존성과 Gradle 플러그인을 추가 한 후에는 먼저 엔티티 객체를 만들어야합니다.

실재

엔티티는 데이터베이스의 일부 데이터를 모델링하는 POJO ( Plain Old Java Object ) 입니다. GreenDao는이 클래스를 사용하여 SQLite 데이터베이스에 테이블을 만들고 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...

}

일회성 GreenDao 설정

응용 프로그램이 시작될 때마다 GreenDao를 초기화해야합니다. GreenDao는이 코드를 Application 클래스 또는 어딘가에 한 번만 실행하도록 제안합니다.

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

GreenDao 도우미 클래스

엔티티 객체가 생성 된 후 GreenDao는 데이터베이스와 상호 작용하는 데 사용되는 도우미 클래스를 자동으로 생성합니다. 이것들은 생성 된 엔티티 객체의 이름과 비슷하게 Dao 가 daoSession 객체에서 검색됩니다.

UsersDao usersDao = daoSession.getUsersDao();

엔티티 객체와 함께이 Dao 객체를 사용하여 많은 일반적인 데이터베이스 작업을 수행 할 수 있습니다.

질문

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

끼워 넣다

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

최신 정보

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

지우다

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