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でエンティティを作成する

コンポジット主キーを持つ表のモデルを作成する場合、モデルEntityがそれらの制約を遵守するためには、オブジェクトに対して追加の作業が必要です。

次のSQLテーブルとエンティティの例は、顧客がオンラインストア内のアイテムのレビューを保存するための構造を示しています。この例では、 customer_idおよびitem_id列を複合主キーにして、特定の顧客とアイテムの間に1つのレビューしか存在させないようにします。

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と呼ばれてい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プラグインを追加したら、最初にエンティティオブジェクトを作成する必要があります。

エンティティ

エンティティは、データベース内の一部のデータをモデル化するPlain Old Java Object （POJO）です。 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);