इस पेज का अनुवाद Cloud Translation API से किया गया है.

रूम के डीएओ इस्तेमाल करके, डेटा को ऐक्सेस करना

जब अपने ऐप्लिकेशन के डेटा को सेव करने के लिए, रूम परसिस्टेंस लाइब्रेरी का इस्तेमाल किया जाता है, तब सेव किए गए डेटा के साथ डेटा ऐक्सेस ऑब्जेक्ट या डीएओ तय करते हैं. सभी डीएओ इसमें ऐसे तरीके शामिल हैं जो आपके ऐप्लिकेशन के डेटाबेस का एब्सट्रैक्ट ऐक्सेस देते हैं. कंपाइलेशन के दौरान समय के हिसाब से, रूम अपने-आप आपके तय किए गए डीएओ लागू करता है.

अपने ऐप्लिकेशन के डेटाबेस को ऐक्सेस करने के लिए, क्वेरी बिल्डर या डायरेक्ट के बजाय डीएओ का इस्तेमाल करके है, तो आप Google Trends को अलग-अलग समस्याओं को हल करना. सिद्धांत. डीएओ, डेटाबेस ऐक्सेस की नकल करना भी आसान बनाते हैं, अपने ऐप्लिकेशन की जांच करें.

एनाटॉमी ऑफ़ अ डीएओ

हर डीएओ को इंटरफ़ेस या ऐब्सट्रैक्ट क्लास के तौर पर बताया जा सकता है. बुनियादी सेटिंग इस्तेमाल करते हैं, तो आम तौर पर इंटरफ़ेस का इस्तेमाल किया जाता है. दोनों ही मामलों में, आपको हमेशा @Dao का इस्तेमाल करके, अपने डीएओ के बारे में बताएं. डीएओ इसमें प्रॉपर्टी नहीं हैं, लेकिन प्रॉपर्टी से इंटरैक्ट करने के लिए, एक या उससे ज़्यादा तरीके बताए गए हैं के डेटा के साथ अपने ऐप्लिकेशन के डेटाबेस में सेव करें.

नीचे दिया गया कोड एक आसान डीएओ का उदाहरण है, जो रूम के डेटाबेस में User ऑब्जेक्ट शामिल करना, मिटाना, और चुनना:

Kotlin

@Dao
interface UserDao {
    @Insert
    fun insertAll(vararg users: User)

    @Delete
    fun delete(user: User)

    @Query("SELECT * FROM user")
    fun getAll(): List<User>
}

Java

@Dao
public interface UserDao {
    @Insert
    void insertAll(User... users);

    @Delete
    void delete(User user);

    @Query("SELECT * FROM user")
    List<User> getAll();
}

डेटाबेस इंटरैक्शन को दो तरह के डीएओ तरीकों से तय किया जाता है:

ऐसी सुविधा विधियां जिनकी मदद से आप अपने कॉलम में पंक्तियां सम्मिलित कर सकते हैं, अपडेट कर सकते हैं और हटा सकते हैं बिना कोई एसक्यूएल कोड लिखे डेटाबेस बनाएं.
क्वेरी के ऐसे तरीके जिनसे आपको इंटरैक्ट करने के लिए खुद की एसक्यूएल क्वेरी लिखने में मदद मिलती है डेटाबेस.

नीचे दिए गए सेक्शन में, दोनों तरह के डीएओ तरीकों का इस्तेमाल करने का तरीका बताया गया है अपने ऐप्लिकेशन के लिए ज़रूरी डेटाबेस इंटरैक्शन तय करें.

आसान तरीके

रूम, आसान परफ़ॉर्म करने वाले तरीके परिभाषित करने के लिए सुविधा एनोटेशन देता है SQL स्टेटमेंट लिखने की ज़रूरत के बिना, इंसर्शन, अपडेट, और मिटाना.

अगर आपको ज़्यादा कॉम्प्लेक्स इंसर्शन, अपडेट या मिटाने की ज़रूरत है या डेटाबेस के डेटा के बारे में क्वेरी करने के लिए, क्वेरी के तरीके का इस्तेमाल करें.

शामिल करें

@Insert एनोटेशन से आपको उन विधियों को परिभाषित करेगा, जो डेटाबेस. नीचे दिए गए कोड में, ऐसे मान्य @Insert तरीकों के उदाहरण दिए गए हैं जो डेटाबेस में एक या उससे ज़्यादा User ऑब्जेक्ट डालें:

Kotlin

@Dao
interface UserDao {
    @Insert(onConflict = OnConflictStrategy.REPLACE)
    fun insertUsers(vararg users: User)

    @Insert
    fun insertBothUsers(user1: User, user2: User)

    @Insert
    fun insertUsersAndFriends(user: User, friends: List<User>)
}

Java

@Dao
public interface UserDao {
    @Insert(onConflict = OnConflictStrategy.REPLACE)
    public void insertUsers(User... users);

    @Insert
    public void insertBothUsers(User user1, User user2);

    @Insert
    public void insertUsersAndFriends(User user, List<User> friends);
}

@Insert तरीके के लिए हर पैरामीटर, रूम का इंस्टेंस होना चाहिए डेटा इकाई की क्लास के साथ एनोटेट किया गया हो @Entity या डेटा इकाई की क्लास के इंस्टेंस का कलेक्शन. इनमें से हर एक इंस्टेंस डेटाबेस के बारे में बताता है. जब @Insert तरीके को कॉल किया जाता है, तो रूम में हर एक तरीके को शामिल किया जाता है इकाई के इंस्टेंस को संबंधित डेटाबेस टेबल में पास कर दिया जाता है.

अगर @Insert तरीके को कोई एक पैरामीटर मिलता है, तो यह long रिटर्न कर सकता है वैल्यू, जो शामिल किए गए आइटम के लिए नया rowId है. अगर पैरामीटर अरे या कलेक्शन दिखाएं, फिर कोई अरे या कलेक्शन दिखाएं के बजाय, long मान का इस्तेमाल किया जाएगा. हर मान, डाले गए किसी एक मान के लिए rowId के तौर पर होगा आइटम. rowId की वैल्यू दिखाने के बारे में ज़्यादा जानने के लिए, रेफ़रंस देखें @Insert के लिए दस्तावेज़ एनोटेशन और rowid के लिए SQLite दस्तावेज़ टेबल.

अपडेट करें

@Update एनोटेशन से आपको उन तरीकों को परिभाषित करें जो डेटाबेस टेबल में खास पंक्तियों को अपडेट करते हैं. किसी ने भी पसंद नहीं किया @Insert तरीके, @Update तरीके डेटा इकाई के इंस्टेंस को पैरामीटर के तौर पर स्वीकार करते हैं. नीचे दिया गया कोड एक ऐसे @Update तरीके का उदाहरण देता है जो डेटाबेस में एक या उससे ज़्यादा User ऑब्जेक्ट अपडेट करें:

Kotlin

@Dao
interface UserDao {
    @Update
    fun updateUsers(vararg users: User)
}

Java

@Dao
public interface UserDao {
    @Update
    public void updateUsers(User... users);
}

रूम, प्राइमरी पास किया गया मैच करने के लिए पासकोड इकाई के इंस्टेंस को डेटाबेस की पंक्तियों में शामिल करें. अगर एक जैसी कोई पंक्ति न हो प्राइमरी बटन है, तो रूम में कोई बदलाव नहीं होता.

@Update वाला तरीका, विकल्प के तौर पर संख्या दिखाने वाली int वैल्यू दे सकता है अपडेट हुई.

मिटाएं

@Delete एनोटेशन से आपको उन तरीकों को परिभाषित करें जो किसी डेटाबेस टेबल से खास पंक्तियों को मिटा देते हैं. किसी ने भी पसंद नहीं किया @Insert तरीके, @Delete तरीके डेटा इकाई के इंस्टेंस को पैरामीटर के तौर पर स्वीकार करते हैं. नीचे दिया गया कोड एक ऐसे @Delete तरीके का उदाहरण देता है जो डेटाबेस से एक या उससे ज़्यादा User ऑब्जेक्ट मिटाएं:

Kotlin

@Dao
interface UserDao {
    @Delete
    fun deleteUsers(vararg users: User)
}

Java

@Dao
public interface UserDao {
    @Delete
    public void deleteUsers(User... users);
}

कोई @Delete तरीका वैकल्पिक रूप से, एक int मान दे सकता है. यह मान बताता है कि पंक्तियां जिन्हें सफलतापूर्वक हटा दिया गया था.

क्वेरी के तरीके

@Query एनोटेशन से आपको SQL स्टेटमेंट लिखें और उन्हें डीएओ मैथड के तौर पर दिखाएं. क्वेरी के इन तरीकों का इस्तेमाल करें आपके ऐप्लिकेशन के डेटाबेस से क्वेरी डेटा या तब, जब आपको ज़्यादा मुश्किल काम करने की ज़रूरत हो सम्मिलित करना, अपडेट करना और हटाना.

रूम, कंपाइल के समय पर एसक्यूएल क्वेरी की पुष्टि करता है. इसका मतलब है कि अगर कोई समस्या आपकी क्वेरी में इस्तेमाल होने पर, रनटाइम के दौरान होने वाली गड़बड़ी के बजाय, कंपाइलेशन से जुड़ी गड़बड़ी होती है.

सिंपल क्वेरी

यह कोड ऐसे तरीके के बारे में बताता है जो नतीजे देने के लिए आसान SELECT क्वेरी का इस्तेमाल करता है डेटाबेस में सभी User ऑब्जेक्ट:

Kotlin

@Query("SELECT * FROM user")
fun loadAllUsers(): Array<User>

Java

@Query("SELECT * FROM user")
public User[] loadAllUsers();

नीचे दिए गए सेक्शन में, सामान्य इस्तेमाल के लिए इस उदाहरण में बदलाव करने का तरीका बताया गया है मामले.

टेबल के कॉलम का सबसेट दिखाना

ज़्यादातर मामलों में, आपको टेबल से कॉलम का सिर्फ़ सबसेट लौटाना होता है क्वेरी की जा रही है. उदाहरण के लिए, आपका यूज़र इंटरफ़ेस (यूआई) सिर्फ़ पहला और उपयोगकर्ता के बारे में हर जानकारी के बजाय उसका उपनाम डालें. सेव करने के लिए और अपनी क्वेरी के निष्पादन को आसान बनाने के लिए, केवल डालें, जिनकी आपको ज़रूरत है.

रूम की मदद से, आपकी किसी भी क्वेरी से सामान्य ऑब्जेक्ट दिखाया जा सकता है. ऐसा सिर्फ़ तब तक के लिए किया जा सकता है, तो नतीजे के कॉलम के सेट को, दिखाए गए ऑब्जेक्ट पर मैप किया जा सकता है. उदाहरण के लिए, आपके उपयोगकर्ता के नाम और उपनाम को होल्ड करने के लिए, नीचे दिया गया ऑब्जेक्ट तय कर सकता है:

Kotlin

data class NameTuple(
    @ColumnInfo(name = "first_name") val firstName: String?,
    @ColumnInfo(name = "last_name") val lastName: String?
)

Java

public class NameTuple {
    @ColumnInfo(name = "first_name")
    public String firstName;

    @ColumnInfo(name = "last_name")
    @NonNull
    public String lastName;
}

इसके बाद, क्वेरी के तरीके से वह ऑब्जेक्ट दिखाया जा सकता है:

Kotlin

@Query("SELECT first_name, last_name FROM user")
fun loadFullName(): List<NameTuple>

Java

@Query("SELECT first_name, last_name FROM user")
public List<NameTuple> loadFullName();

रूम समझता है कि क्वेरी, first_name और last_name कॉलम जनरेट किए जा सकते हैं और इन वैल्यू को कॉलम में मौजूद फ़ील्ड पर मैप किया जा सकता है NameTuple क्लास. अगर क्वेरी से ऐसा कॉलम दिखता है जो किसी फ़ील्ड पर मैप नहीं करता दिखाए गए ऑब्जेक्ट में, रूम एक चेतावनी दिखाता है.

किसी क्वेरी में आसान पैरामीटर पास करें

ज़्यादातर डीएओ तरीकों को पैरामीटर स्वीकार करने की ज़रूरत होती है, ताकि वे फ़िल्टर करने का काम करती है. रूम में, बाइंड के तौर पर मेथड के पैरामीटर का इस्तेमाल किया जा सकता है पैरामीटर की संख्या.

उदाहरण के लिए, नीचे दिया गया कोड एक ऐसा तरीका तय करता है जिससे सभी उपयोगकर्ता तय उम्र से ज़्यादा होने पर:

Kotlin

@Query("SELECT * FROM user WHERE age > :minAge")
fun loadAllUsersOlderThan(minAge: Int): Array<User>

Java

@Query("SELECT * FROM user WHERE age > :minAge")
public User[] loadAllUsersOlderThan(int minAge);

आपके पास एक से ज़्यादा पैरामीटर पास करने या एक ही पैरामीटर को रेफ़रंस के तौर पर इस्तेमाल करने का विकल्प है क्वेरी में बार, जैसा कि नीचे दिए गए कोड में दिखाया गया है:

Kotlin

@Query("SELECT * FROM user WHERE age BETWEEN :minAge AND :maxAge")
fun loadAllUsersBetweenAges(minAge: Int, maxAge: Int): Array<User>

@Query("SELECT * FROM user WHERE first_name LIKE :search " +
       "OR last_name LIKE :search")
fun findUserWithName(search: String): List<User>

Java

@Query("SELECT * FROM user WHERE age BETWEEN :minAge AND :maxAge")
public User[] loadAllUsersBetweenAges(int minAge, int maxAge);

@Query("SELECT * FROM user WHERE first_name LIKE :search " +
       "OR last_name LIKE :search")
public List<User> findUserWithName(String search);

किसी क्वेरी में पैरामीटर का कलेक्शन पास करना

कुछ डीएओ तरीकों के लिए, आपको ऐसे पैरामीटर जिनके बारे में रनटाइम तक पता नहीं चलता. चैट रूम तब समझता है, जब कोई पैरामीटर यह कलेक्शन को दिखाता है और रनटाइम के दौरान इस आधार पर अपने-आप बड़ा करता है पैरामीटर की संख्या दी गई है.

उदाहरण के लिए, नीचे दिया गया कोड एक ऐसा तरीका तय करता है जो क्षेत्रों के किसी सबसेट से सभी उपयोगकर्ता:

Kotlin

@Query("SELECT * FROM user WHERE region IN (:regions)")
fun loadUsersFromRegions(regions: List<String>): List<User>

Java

@Query("SELECT * FROM user WHERE region IN (:regions)")
public List<User> loadUsersFromRegions(List<String> regions);

कई टेबल पर क्वेरी करें

आपकी कुछ क्वेरी को नतीजा. अपनी एसक्यूएल क्वेरी में JOIN क्लॉज़ का इस्तेमाल, इससे ज़्यादा रेफ़रंस के लिए किया जा सकता है एक टेबल होगी.

यह कोड एक ऐसे तरीके के बारे में बताता है जो नतीजे देने के लिए तीन टेबल को एक साथ जोड़ता है फ़िलहाल, किसी उपयोगकर्ता के लिए क़र्ज़ पर दी जाने वाली किताबें:

Kotlin

@Query(
    "SELECT * FROM book " +
    "INNER JOIN loan ON loan.book_id = book.id " +
    "INNER JOIN user ON user.id = loan.user_id " +
    "WHERE user.name LIKE :userName"
)
fun findBooksBorrowedByNameSync(userName: String): List<Book>

Java

@Query("SELECT * FROM book " +
       "INNER JOIN loan ON loan.book_id = book.id " +
       "INNER JOIN user ON user.id = loan.user_id " +
       "WHERE user.name LIKE :userName")
public List<Book> findBooksBorrowedByNameSync(String userName);

एक से ज़्यादा कॉलम से कॉलम का सबसेट देने के लिए, आसान ऑब्जेक्ट भी तय किए जा सकते हैं शामिल की गई टेबल, जैसा कि टेबल की वैल्यू का सबसेट दिखाना कॉलम सेक्शन में कॉपी किया जा सकता है. यह कोड किसी डीएओ को ऐसे तरीके से परिभाषित करता है जो उपयोगकर्ताओं के नाम और उनसे ली गई किताबों के नाम दिखाता है:

Kotlin

interface UserBookDao {
    @Query(
        "SELECT user.name AS userName, book.name AS bookName " +
        "FROM user, book " +
        "WHERE user.id = book.user_id"
    )
    fun loadUserAndBookNames(): LiveData<List<UserBook>>

    // You can also define this class in a separate file.
    data class UserBook(val userName: String?, val bookName: String?)
}

Java

@Dao
public interface UserBookDao {
   @Query("SELECT user.name AS userName, book.name AS bookName " +
          "FROM user, book " +
          "WHERE user.id = book.user_id")
   public LiveData<List<UserBook>> loadUserAndBookNames();

   // You can also define this class in a separate file, as long as you add the
   // "public" access modifier.
   static class UserBook {
       public String userName;
       public String bookName;
   }
}

मल्टीमैप दिखाना

रूम 2.4 और उसके बाद के वर्शन में, आपके पास कई टेबल के कॉलम के लिए क्वेरी करने का विकल्प भी है क्वेरी के ऐसे तरीके लिखकर अतिरिक्त डेटा क्लास तय करते हैं जो नतीजे के तौर पर मल्टीमैप.

एक से ज़्यादा टेबल के लिए क्वेरी करें सेक्शन से दिए गए उदाहरण पर विचार करें. मौजूदा कस्टम डेटा क्लास के इंस्टेंस की सूची दिखाने के बजाय User और Book इंस्टेंस को जोड़ने पर, User और सीधे आपके क्वेरी तरीके से Book:

Kotlin

@Query(
    "SELECT * FROM user" +
    "JOIN book ON user.id = book.user_id"
)
fun loadUserAndBookNames(): Map<User, List<Book>>

Java

@Query(
    "SELECT * FROM user" +
    "JOIN book ON user.id = book.user_id"
)
public Map<User, List<Book>> loadUserAndBookNames();

जब क्वेरी का आपका तरीका मल्टीमैप दिखाता है, तो आपके पास ऐसी क्वेरी लिखने का विकल्प होता है जिनमें GROUP BY क्लॉज़, जो एसक्यूएल की सुविधाओं का फ़ायदा देते हैं हिसाब लगाने और फ़िल्टर करने की ऐडवांस सुविधाएं देते हैं. उदाहरण के लिए, आप उन उपयोगकर्ताओं को लौटाने के लिए loadUserAndBookNames() तरीका जिनके पास तीन या उससे ज़्यादा किताबें हैं चेक आउट किया गया:

Kotlin

@Query(
    "SELECT * FROM user" +
    "JOIN book ON user.id = book.user_id" +
    "GROUP BY user.name WHERE COUNT(book.id) >= 3"
)
fun loadUserAndBookNames(): Map<User, List<Book>>

Java

@Query(
    "SELECT * FROM user" +
    "JOIN book ON user.id = book.user_id" +
    "GROUP BY user.name WHERE COUNT(book.id) >= 3"
)
public Map<User, List<Book>> loadUserAndBookNames();

अगर आपको सभी ऑब्जेक्ट को मैप करने की ज़रूरत नहीं है, तो इनके बीच में भी मैपिंग को वापस किया जा सकता है किसी कॉलम में बदलाव करने के लिए, keyColumn और valueColumn एट्रिब्यूट आपकी@MapInfo क्वेरी का तरीका:

Kotlin

@MapInfo(keyColumn = "userName", valueColumn = "bookName")
@Query(
    "SELECT user.name AS username, book.name AS bookname FROM user" +
    "JOIN book ON user.id = book.user_id"
)
fun loadUserAndBookNames(): Map<String, List<String>>

Java

@MapInfo(keyColumn = "userName", valueColumn = "bookName")
@Query(
    "SELECT user.name AS username, book.name AS bookname FROM user" +
    "JOIN book ON user.id = book.user_id"
)
public Map<String, List<String>> loadUserAndBookNames();

सामान लौटाने के खास तरीके

रूम, अन्य एपीआई के साथ इंटिग्रेशन के लिए, सामान लौटाने की कुछ खास सुविधाएं देता है लाइब्रेरी.

पेजिंग लाइब्रेरी की मदद से, पेजों में नंबर डालकर की गई क्वेरी

पेजिंग लाइब्रेरी पर जाएं. रूम 2.3.0-alpha01 और ज़्यादा, डीएओ वापस आ सकते हैं इस्तेमाल करने के लिए PagingSource ऑब्जेक्ट पेजिंग 3 के साथ.

Kotlin

@Dao
interface UserDao {
  @Query("SELECT * FROM users WHERE label LIKE :query")
  fun pagingSource(query: String): PagingSource<Int, User>
}

Java

@Dao
interface UserDao {
  @Query("SELECT * FROM users WHERE label LIKE :query")
  PagingSource<Integer, User> pagingSource(String query);
}

PagingSource के लिए टाइप पैरामीटर चुनने के बारे में ज़्यादा जानने के लिए, देखें कुंजी और मान चुनें टाइप.

कर्सर को सीधे तौर पर ऐक्सेस करना

अगर आपके ऐप्लिकेशन के लॉजिक के लिए रिटर्न पंक्तियों का सीधा ऐक्सेस चाहिए, तो Cursor वापस करने के लिए, आपके डीएओ तरीके ऑब्जेक्ट, जैसा कि नीचे दिए गए उदाहरण में दिखाया गया है:

Kotlin

@Dao
interface UserDao {
    @Query("SELECT * FROM user WHERE age > :minAge LIMIT 5")
    fun loadRawUsersOlderThan(minAge: Int): Cursor
}

Java

@Dao
public interface UserDao {
    @Query("SELECT * FROM user WHERE age > :minAge LIMIT 5")
    public Cursor loadRawUsersOlderThan(int minAge);
}

चेतावनी: हम Cursor API का इस्तेमाल करने का सुझाव नहीं देते, क्योंकि यह नहीं करता गारंटी है कि पंक्तियां मौजूद हैं या पंक्तियों में कौन-कौनसी वैल्यू हैं. सिर्फ़ इसका इस्तेमाल करें फ़ंक्शन का इस्तेमाल तब किया जा सकता है, जब आपके पास पहले से ही ऐसा कोड हो जो कर्सर की उम्मीद करता हो और जिसे ऐक्सेस नहीं किया जा सकता आसानी से रीफ़ैक्टर किया जा सकता है.

अन्य संसाधन

रूम के डीएओ इस्तेमाल करके डेटा ऐक्सेस करने के बारे में ज़्यादा जानने के लिए, यहां दी गई अतिरिक्त जानकारी देखें संसाधन:

सैंपल

Android सनफ़्लावर

कोड लैब

व्यू वाला Android रूम (Java) (Kotlin)

पीछे जाएं

इकाइयों का इस्तेमाल करके डेटा तय करें

आगे बढ़ें

ऑब्जेक्ट के बीच का संबंध बताना