הגדרה של קשרי גומלין 'הרבה לרבים' ושליחת שאילתות לגבי קשרים כאלה
קל לארגן דפים בעזרת אוספים
אפשר לשמור ולסווג תוכן על סמך ההעדפות שלך.
קשר 'הרבה לרבים' בין שתי ישויות הוא קשר שבו כל מופע של הישות האב תואם לאפס או יותר מופעים של הישות הצאצא, וההפך נכון גם כן.
בדוגמה של אפליקציית הסטרימינג של המוזיקה, נתייחס לשירים בפלייליסטים שהוגדרו על ידי המשתמש. כל פלייליסט יכול לכלול הרבה שירים, וכל שיר יכול להיכלל בהרבה פלייליסטים שונים. לכן, יש קשר 'הרבה לרבים' בין הישות Playlist לישות Song.
כדי להגדיר יחסי 'רבים לרבים' במסד הנתונים ולבצע שאילתות לגביהן:
הגדרת הקשר: מגדירים את הישויות ואת הישות המשויכת (טבלת הפניה חוזרת) כדי לייצג את הקשר 'הרבה לרבים'.
שליחת שאילתות לישויות: קובעים איך שולחים שאילתות לישויות הקשורות ויוצרים כיתות נתונים שמייצגות את הפלט המיועד.
הגדרת הקשר
כדי להגדיר קשר 'הרבה לרבים', קודם צריך ליצור כיתה לכל אחת משתי הישות. קשרים 'רבים לרבים' שונים מסוגים אחרים של קשרים, כי בדרך כלל אין הפניה לישות ההורה בישות הצאצא. במקום זאת, יוצרים כיתה שלישית שמייצגת ישות אסוסיאיטיבית או טבלת הפניה בין שתי הישויות.
בטבלת הפניה ההדדית חייבות להיות עמודות למפתח הראשי של כל ישות ביחס ה'רבים לרבים' שמיוצג בטבלה. בדוגמה הזו, כל שורה בטבלת ההפניות ההדדיות תואמת להתאמה של מכונה של Playlist ומכונה של Song, שבה השיר שמצוין בפניה נכלל בפלייליסט שמצוין בפניה.
השלב הבא תלוי באופן שבו רוצים לשלוח שאילתה לגבי הישות הקשורות האלה.
אם רוצים לשלוח שאילתה לגבי פלייליסטים ורשימה של השירים התואמים לכל פלייליסט, צריך ליצור סיווג נתונים חדש שמכיל אובייקט Playlist אחד ורשימה של כל אובייקטי ה-Song שהפלייליסט כולל.
אם רוצים לשלוח שאילתה לגבי שירים ולקבל רשימה של הפלייליסטים התואמים לכל אחד מהם, צריך ליצור סיווג נתונים חדש שמכיל אובייקט Song יחיד ורשימה של כל אובייקטי ה-Playlist שבהם השיר נכלל.
בכל מקרה, כדי ליצור מודל של הקשר בין הישויות, משתמשים במאפיין associateBy בהערה @Relation בכל אחת מהכיתות האלה כדי לזהות את ישות ההפניה ההדדית שמספקת את הקשר בין הישות Playlist לישות Song.
לבסוף, מוסיפים שיטה לכיתה DAO כדי לחשוף את פונקציית השאילתה שנדרשת לאפליקציה.
getPlaylistsWithSongs: השיטה שולחת שאילתה למסד הנתונים ומחזירה את כל אובייקטי ה-PlaylistWithSongs שנוצרו.
getSongsWithPlaylists: השיטה שולחת שאילתה למסד הנתונים ומחזירה את כל אובייקטי ה-SongWithPlaylists שנוצרו.
כל אחת מהשיטות האלה דורשת מ-Room להריץ שתי שאילתות, לכן צריך להוסיף את ההערה @Transaction לשתי השיטות כדי שהפעולה כולה תתבצע באופן אטומי.
Kotlin
@Transaction@Query("SELECT * FROM Playlist")fungetPlaylistsWithSongs():List<PlaylistWithSongs>@Transaction@Query("SELECT * FROM Song")fungetSongsWithPlaylists():List<SongWithPlaylists>
Java
@Transaction@Query("SELECT * FROM Playlist")publicList<PlaylistWithSongs>getPlaylistsWithSongs();@Transaction@Query("SELECT * FROM Song")publicList<SongWithPlaylists>getSongsWithPlaylists();
דוגמאות התוכן והקוד שבדף הזה כפופות לרישיונות המפורטים בקטע רישיון לתוכן. 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 many-to-many relationships\n\nA *many-to-many relationship* between two entities is a relationship where each\ninstance of the parent entity corresponds to zero or more instances of the child\nentity, and the reverse is also true.\n\nIn the music streaming app example, consider the songs in the user-defined\nplaylists. Each playlist can include many songs, and each song can be a part of\nmany different playlists. Therefore, there is a many-to-many relationship\nbetween the `Playlist` entity and the `Song` entity.\n\nFollow these steps to define and query many-to-many relationships in your\ndatabase:\n\n1. **[Define the relationship](#define)**: Establish the entities and the associative entity (cross-reference table) to represent the many-to-many relationship.\n2. **[Query the entities](#query)**: Determine how you want to query the related entities and create data classes to represent the intended output.\n\nDefine the relationship\n-----------------------\n\nTo define a many-to-many relationship, first create a class for each of your two\nentities. Many-to-many relationships are distinct from other relationship types\nbecause there is generally no reference to the parent entity in the child\nentity. Instead, create a third class to represent an [associative\nentity](https://en.wikipedia.org/wiki/Associative_entity), or *cross-reference table* , between the two entities.\nThe cross-reference table must have columns for the primary key from each entity\nin the many-to-many relationship represented in the table. In this example, each\nrow in the cross-reference table corresponds to a pairing of a `Playlist`\ninstance and a `Song` instance where the referenced song is included in the\nreferenced playlist. \n\n### Kotlin\n\n @Entity\n data class Playlist(\n @PrimaryKey val playlistId: Long,\n val playlistName: String\n )\n\n @Entity\n data class Song(\n @PrimaryKey val songId: Long,\n val songName: String,\n val artist: String\n )\n\n @Entity(primaryKeys = [\"playlistId\", \"songId\"])\n data class PlaylistSongCrossRef(\n val playlistId: Long,\n val songId: Long\n )\n\n### Java\n\n @Entity\n public class Playlist {\n @PrimaryKey public long playlistId;\n public String playlistName;\n }\n\n @Entity\n public class Song {\n @PrimaryKey public long songId;\n public String songName;\n public String artist;\n }\n\n @Entity(primaryKeys = {\"playlistId\", \"songId\"})\n public class PlaylistSongCrossRef {\n public long playlistId;\n public long songId;\n }\n\nQuery the entities\n------------------\n\nThe next step depends on how you want to query these related entities.\n\n- If you want to query *playlists* and a list of the corresponding *songs* for each playlist, create a new data class that contains a single `Playlist` object and a list of all of the `Song` objects that the playlist includes.\n- If you want to query *songs* and a list of the corresponding *playlists* for each, create a new data class that contains a single `Song` object and a list of all of the `Playlist` objects in which the song is included.\n\nIn either case, model the relationship between the entities by using the\n[`associateBy`](/reference/kotlin/androidx/room/Relation#associateBy()) property in the [`@Relation`](/reference/kotlin/androidx/room/Relation) annotation in each of these\nclasses to identify the cross-reference entity providing the relationship\nbetween the `Playlist` entity and the `Song` entity. \n\n### Kotlin\n\n data class PlaylistWithSongs(\n @Embedded val playlist: Playlist,\n @Relation(\n parentColumn = \"playlistId\",\n entityColumn = \"songId\",\n associateBy = Junction(PlaylistSongCrossRef::class)\n )\n val songs: List\u003cSong\u003e\n )\n\n data class SongWithPlaylists(\n @Embedded val song: Song,\n @Relation(\n parentColumn = \"songId\",\n entityColumn = \"playlistId\",\n associateBy = Junction(PlaylistSongCrossRef::class)\n )\n val playlists: List\u003cPlaylist\u003e\n )\n\n### Java\n\n public class PlaylistWithSongs {\n @Embedded public Playlist playlist;\n @Relation(\n parentColumn = \"playlistId\",\n entityColumn = \"songId\",\n associateBy = @Junction(PlaylistSongCrossref.class)\n )\n public List\u003cSong\u003e songs;\n }\n\n public class SongWithPlaylists {\n @Embedded public Song song;\n @Relation(\n parentColumn = \"songId\",\n entityColumn = \"playlistId\",\n associateBy = @Junction(PlaylistSongCrossref.class)\n )\n public List\u003cPlaylist\u003e playlists;\n }\n\nFinally, add a method to the DAO class to expose the query function your\napp needs.\n\n- `getPlaylistsWithSongs`: this method queries the database and returns all the resulting `PlaylistWithSongs` objects.\n- `getSongsWithPlaylists`: this method queries the database and returns all the resulting `SongWithPlaylists` objects.\n\nThese methods each require Room to run two queries, so add the\n[`@Transaction`](/reference/kotlin/androidx/room/Transaction) annotation to both methods so that the whole\noperation is performed atomically. \n\n### Kotlin\n\n @Transaction\n @Query(\"SELECT * FROM Playlist\")\n fun getPlaylistsWithSongs(): List\u003cPlaylistWithSongs\u003e\n\n @Transaction\n @Query(\"SELECT * FROM Song\")\n fun getSongsWithPlaylists(): List\u003cSongWithPlaylists\u003e\n\n### Java\n\n @Transaction\n @Query(\"SELECT * FROM Playlist\")\n public List\u003cPlaylistWithSongs\u003e getPlaylistsWithSongs();\n\n @Transaction\n @Query(\"SELECT * FROM Song\")\n public List\u003cSongWithPlaylists\u003e getSongsWithPlaylists();\n\n| **Note:** If the `@Relation` annotation does not meet your specific use case, you might need to use the `JOIN` keyword in your SQL queries to manually define the appropriate relationships. To learn more about querying multiple tables manually, read [Accessing data using Room\n| DAOs](/training/data-storage/room/accessing-data#query-multiple-tables)."]]