Android
GreenDAO

परिचय

चयन, INSERT, DELETE, अद्यतन प्रश्नों के लिए सहायक विधियाँ

यह उदाहरण एक सहायक वर्ग को दिखाता है जिसमें डेटा के लिए प्रश्नों को निष्पादित करते समय उपयोगी विधियां शामिल हैं। यहां हर विधि बहुत लचीली होने के लिए जावा जेनेरिक का उपयोग करती है।

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 के साथ एक इकाई बनाना जिसमें एक कंपोजिट प्राइमरी की है

समग्र प्राथमिक कुंजी वाली तालिका के लिए मॉडल बनाते समय, उन बाधाओं का सम्मान करने के लिए मॉडल इकाई के लिए ऑब्जेक्ट पर अतिरिक्त कार्य आवश्यक है।

निम्न उदाहरण SQL टेबल और Entity ऑनलाइन स्टोर में किसी आइटम के लिए ग्राहक द्वारा छोड़ी गई समीक्षा को संग्रहीत करने के लिए संरचना को प्रदर्शित करता है। इस उदाहरण में, हम चाहते हैं कि customer_id और item_id कॉलम एक समग्र प्राथमिक कुंजी हों, जिससे किसी विशिष्ट ग्राहक और आइटम के बीच केवल एक समीक्षा मौजूद हो।

एसक्यूएल टेबल

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

आमतौर पर हम इकाई वर्ग में संबंधित क्षेत्रों के ऊपर @Unique @Id और @Unique एनोटेशन का उपयोग करते हैं, हालांकि एक समग्र प्राथमिक कुंजी के लिए हम निम्नलिखित करते हैं:

1. क्लास-स्तर @Entity @Index एनोटेशन के अंदर @Index एनोटेशन जोड़ें। मान गुण में फ़ील्ड्स की एक अल्पविराम-सीमांकित सूची होती है जो कुंजी बनाती है। unique गुण का उपयोग करें जैसा कि कुंजी पर विशिष्टता को लागू करने के लिए दिखाया गया है।

2. GreenDAO की आवश्यकता है प्रत्येक संस्था के पास एक प्राथमिक कुंजी के रूप में एक long या Long वस्तु है। हमें अभी भी इसे एंटिटी वर्ग में जोड़ने की आवश्यकता है, हालांकि हमें इसका उपयोग करने की आवश्यकता नहीं है या हमारे कार्यान्वयन को प्रभावित करने के बारे में चिंता करने की आवश्यकता नहीं है। नीचे के उदाहरण में इसे 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 के साथ आरंभ करना

ग्रीनडाओ लाइब्रेरी निर्भरता और ग्रेडल प्लगइन को जोड़ने के बाद, हमें पहले एक इकाई ऑब्जेक्ट बनाने की आवश्यकता है।

सत्ता

एक इकाई एक सादा पुराना जावा ऑब्जेक्ट (POJO) है जो डेटाबेस में कुछ डेटा को मॉडल करता है। ग्रीनडॉ इस वर्ग का उपयोग 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 को इनिशियलाइज़ करना पड़ता है। ग्रीनडॉ सुझाव देता है कि इस कोड को एक एप्लिकेशन क्लास में रखा जाए या कहीं इसे केवल एक बार चलाया जाएगा।

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

ग्रीनडाओ हेल्पर कक्षाएं

इकाई ऑब्जेक्ट बनने के बाद, GreenDao स्वचालित रूप से डेटाबेस के साथ बातचीत करने के लिए उपयोग की जाने वाली सहायक कक्षाएं बनाता है। इनका नाम उस इकाई ऑब्जेक्ट के नाम के समान रखा गया है जिसे Dao द्वारा बनाया गया था, और daoSession ऑब्जेक्ट से पुनर्प्राप्त किया daoSession है।

UsersDao usersDao = daoSession.getUsersDao();

कई विशिष्ट डेटाबेस क्रियाओं को इस ऑब्जेक्ट के साथ इस ऑब्जेक्ट के उपयोग से किया जा सकता है।

सवाल

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