הגדרה של קשרים אחד לאחד ושליחת שאילתות לגבי קשרים כאלה
קל לארגן דפים בעזרת אוספים
אפשר לשמור ולסווג תוכן על סמך ההעדפות שלך.
קשר אחד-לאחד בין שתי ישויות הוא קשר שבו כל מופע של הישות ההורה תואם למופע אחד בלבד של הישות הצאצא, ולהפך.
לדוגמה, נניח שיש אפליקציית סטרימינג של מוזיקה שבה למשתמש יש ספרייה של שירים שבבעלותו. לכל משתמש יש רק ספרייה אחת, וכל ספרייה תואמת למשתמש אחד בלבד. לכן, יש קשר אחד לאחד בין הישות User
לישות Library
.
כדי להגדיר יחסי אחד-לאחד במסד הנתונים ולבצע שאילתות לגביהן:
- הגדרת הקשר: יוצרים כיתות לשני הישויות, ומוודאים שאחד מהם מפנה למפתח הראשי של השני.
- שליחת שאילתה לישויות: יוצרים מודל של הקשר בכיתה נתונים חדשה ויוצרים שיטה לאחזור הנתונים הקשורים.
הגדרת הקשר
כדי להגדיר קשר אחד-לאחד, קודם צריך ליצור כיתה לכל אחת משתי הישות. אחת מהישויות חייבת לכלול משתנה שהוא הפניה למפתח הראשי של הישות השנייה.
Kotlin
@Entity
data class User(
@PrimaryKey val userId: Long,
val name: String,
val age: Int
)
@Entity
data class Library(
@PrimaryKey val libraryId: Long,
val userOwnerId: Long
)
Java
@Entity
public class User {
@PrimaryKey public long userId;
public String name;
public int age;
}
@Entity
public class Library {
@PrimaryKey public long libraryId;
public long userOwnerId;
}
שליחת שאילתה לגבי הישויות
כדי לשלוח שאילתה לרשימת המשתמשים ולספריות התואמות, קודם צריך ליצור מודל של היחס האחד-ל-אחד בין שתי הישות.
כדי לעשות זאת, יוצרים סוג נתונים חדש שבו כל מופע מכיל מופע של הישות ההורה ומופע תואם של הישות הצאצא. מוסיפים את ההערה @Relation
למופעים של הישות הצאצא, כאשר parentColumn
מוגדר לשם העמודה של המפתח הראשי של הישות ההורה ו-entityColumn
מוגדר לשם העמודה של הישות הצאצא שמפנה למפתח הראשי של הישות ההורה.
Kotlin
data class UserAndLibrary(
@Embedded val user: User,
@Relation(
parentColumn = "userId",
entityColumn = "userOwnerId"
)
val library: Library
)
Java
public class UserAndLibrary {
@Embedded public User user;
@Relation(
parentColumn = "userId",
entityColumn = "userOwnerId"
)
public Library library;
}
לבסוף, מוסיפים שיטה לכיתה DAO שמחזירה את כל המופעים של כיתה הנתונים שמתאימים את הישות ההורה לישות הצאצא. כדי להשתמש בשיטה הזו, צריך להריץ ב-Room שתי שאילתות. לכן צריך להוסיף את ההערה @Transaction
לשיטה הזו. כך מוודאים שהפעולה כולה מתבצעת באופן אטומי.
Kotlin
@Transaction
@Query("SELECT * FROM User")
fun getUsersAndLibraries(): List<UserAndLibrary>
Java
@Transaction
@Query("SELECT * FROM User")
public List<UserAndLibrary> getUsersAndLibraries();
דוגמאות התוכן והקוד שבדף הזה כפופות לרישיונות המפורטים בקטע רישיון לתוכן. Java ו-OpenJDK הם סימנים מסחריים או סימנים מסחריים רשומים של חברת Oracle ו/או של השותפים העצמאיים שלה.
עדכון אחרון: 2025-07-27 (שעון UTC).
[[["התוכן קל להבנה","easyToUnderstand","thumb-up"],["התוכן עזר לי לפתור בעיה","solvedMyProblem","thumb-up"],["סיבה אחרת","otherUp","thumb-up"]],[["חסרים לי מידע או פרטים","missingTheInformationINeed","thumb-down"],["התוכן מורכב מדי או עם יותר מדי שלבים","tooComplicatedTooManySteps","thumb-down"],["התוכן לא עדכני","outOfDate","thumb-down"],["בעיה בתרגום","translationIssue","thumb-down"],["בעיה בדוגמאות/בקוד","samplesCodeIssue","thumb-down"],["סיבה אחרת","otherDown","thumb-down"]],["עדכון אחרון: 2025-07-27 (שעון UTC)."],[],[],null,["# Define and query one-to-one relationships\n\nA *one-to-one relationship* between two entities is a relationship where each\ninstance of the parent entity corresponds to exactly one instance of the child\nentity, and the reverse is also true.\n\nFor example, consider a music streaming app where the user has a library of\nsongs that they own. Each user has only one library, and each library\ncorresponds to exactly one user. Therefore, there is a one-to-one relationship\nbetween the `User` entity and the `Library` entity.\n\nFollow these steps to define and query one-to-one relationships in your\ndatabase:\n\n1. **[Define the relationship](#define)**: Create classes for both entities, ensuring one references the other's primary key.\n2. **[Query the entities](#query)**: Model the relationship in a new data class and create a method to retrieve the related data.\n\nDefine the relationship\n-----------------------\n\nTo define a one-to-one relationship, first create a class for each of your two\nentities. One of the entities must include a variable that is a reference to the\nprimary key of the other entity. \n\n### Kotlin\n\n @Entity\n data class User(\n @PrimaryKey val userId: Long,\n val name: String,\n val age: Int\n )\n\n @Entity\n data class Library(\n @PrimaryKey val libraryId: Long,\n val userOwnerId: Long\n )\n\n### Java\n\n @Entity\n public class User {\n @PrimaryKey public long userId;\n public String name;\n public int age;\n }\n\n @Entity\n public class Library {\n @PrimaryKey public long libraryId;\n public long userOwnerId;\n }\n\nQuery the entities\n------------------\n\nTo query the list of users and corresponding libraries, you must first model the\none-to-one relationship between the two entities.\n\nTo do this, create a new data class where each instance holds an instance of the\nparent entity and the corresponding instance of the child entity. Add the\n[`@Relation`](/reference/kotlin/androidx/room/Relation) annotation to the instance of the child entity, with\n[`parentColumn`](/reference/kotlin/androidx/room/Relation#parentcolumn()) set to the name of the primary key column of the parent\nentity and [`entityColumn`](/reference/kotlin/androidx/room/Relation#entitycolumn()) set to the name of the column of the child entity\nthat references the parent entity's primary key. \n\n### Kotlin\n\n data class UserAndLibrary(\n @Embedded val user: User,\n @Relation(\n parentColumn = \"userId\",\n entityColumn = \"userOwnerId\"\n )\n val library: Library\n )\n\n### Java\n\n public class UserAndLibrary {\n @Embedded public User user;\n @Relation(\n parentColumn = \"userId\",\n entityColumn = \"userOwnerId\"\n )\n public Library library;\n }\n\nFinally, add a method to the DAO class that returns all instances of the data\nclass that pairs the parent entity and the child entity. This method requires\nRoom to run two queries. You should therefore add the [`@Transaction`](/reference/kotlin/androidx/room/Transaction)\nannotation to this method. This ensures that the whole operation runs\natomically. \n\n### Kotlin\n\n @Transaction\n @Query(\"SELECT * FROM User\")\n fun getUsersAndLibraries(): List\u003cUserAndLibrary\u003e\n\n### Java\n\n @Transaction\n @Query(\"SELECT * FROM User\")\n public List\u003cUserAndLibrary\u003e getUsersAndLibraries();"]]