Verschachtelte Beziehungen definieren und abfragen

Manchmal müssen Sie möglicherweise eine Reihe von drei oder mehr Tabellen abfragen, die alle miteinander verknüpft sind. In diesem Fall definieren Sie verschachtelte Beziehungen zwischen den Tabellen.

Angenommen, Sie möchten im Beispiel der Musikstreaming-App alle Nutzer, alle Playlists für jeden Nutzer und alle Songs in jeder Playlist für jeden Nutzer abfragen. Nutzer haben eine 1:n-Beziehung zu Playlists und Playlists haben eine n:m-Beziehung zu Songs. Im folgenden Codebeispiel sind die Klassen dargestellt, die diese Entitäten darstellen, sowie die Querverweistabelle für die n:m-Beziehung zwischen Playlists und Songs:

Kotlin

@Entity
data class User(
    @PrimaryKey val userId: Long,
    val name: String,
    val age: Int
)

@Entity
data class Playlist(
    @PrimaryKey val playlistId: Long,
    val userCreatorId: Long,
    val playlistName: String
)

@Entity
data class Song(
    @PrimaryKey val songId: Long,
    val songName: String,
    val artist: String
)

@Entity(primaryKeys = ["playlistId", "songId"])
data class PlaylistSongCrossRef(
    val playlistId: Long,
    val songId: Long
)

Java

@Entity
public class User {
    @PrimaryKey public long userId;
    public String name;
    public int age;
}

@Entity
public class Playlist {
    @PrimaryKey public long playlistId;
    public long userCreatorId;
    public String playlistName;
}
@Entity
public class Song {
    @PrimaryKey public long songId;
    public String songName;
    public String artist;
}

@Entity(primaryKeys = {"playlistId", "songId"})
public class PlaylistSongCrossRef {
    public long playlistId;
    public long songId;
}

Modellieren Sie zuerst die Beziehung zwischen zwei der Tabellen in Ihrem Set wie Sie normalerweise tun, mit einer Datenklasse und der @Relation Annotation. Im folgenden Beispiel wird eine PlaylistWithSongs Klasse gezeigt, die eine n:m Beziehung zwischen der Entitätsklasse Playlist und der Entitätsklasse Song modelliert:

Kotlin

data class PlaylistWithSongs(
    @Embedded val playlist: Playlist,
    @Relation(
         parentColumn = "playlistId",
         entityColumn = "songId",
         associateBy = Junction(PlaylistSongCrossRef::class)
    )
    val songs: List<Song>
)

Java

public class PlaylistWithSongs {
    @Embedded public Playlist playlist;
    @Relation(
         parentColumn = "playlistId",
         entityColumn = "songId",
         associateBy = Junction(PlaylistSongCrossRef.class)
    )
    public List<Song> songs;
}

Nachdem Sie eine Datenklasse definiert haben, die diese Beziehung darstellt, erstellen Sie eine weitere Datenklasse, die die Beziehung zwischen einer anderen Tabelle aus Ihrem Set und der ersten Beziehungsklasse modelliert. Dabei wird die vorhandene Beziehung in die neue Beziehung „verschachtelt“. Im folgenden Beispiel wird eine UserWithPlaylistsAndSongs-Klasse gezeigt, die eine 1:n-Beziehung zwischen der Entitätsklasse User und der PlaylistWithSongs-Beziehungsklasse modelliert:

Kotlin

data class UserWithPlaylistsAndSongs(
    @Embedded val user: User
    @Relation(
        entity = Playlist::class,
        parentColumn = "userId",
        entityColumn = "userCreatorId"
    )
    val playlists: List<PlaylistWithSongs>
)

Java

public class UserWithPlaylistsAndSongs {
    @Embedded public User user;
    @Relation(
        entity = Playlist.class,
        parentColumn = "userId",
        entityColumn = "userCreatorId"
    )
    public List<PlaylistWithSongs> playlists;
}

Die UserWithPlaylistsAndSongs Klasse modelliert indirekt die Beziehungen zwischen allen drei Entitätsklassen: User, Playlist, und Song. Das ist in Abbildung 1 dargestellt.

Das Modell „UserWithPlaylistsAndSongs“ bildet die Beziehung zwischen „User“ und „PlaylistWithSongs“ ab, das wiederum die Beziehung zwischen „Playlist“ und „Song“ abbildet.
Abbildung 1. Diagramm der Beziehungsklassen im Beispiel der Musikstreaming-App.

Wenn Ihr Set weitere Tabellen enthält, erstellen Sie eine Klasse, um die Beziehung zwischen jeder verbleibenden Tabelle und der Beziehungsklasse zu modellieren, die die Beziehungen zwischen allen vorherigen Tabellen modelliert. Dadurch entsteht eine Kette verschachtelter Beziehungen zwischen allen Tabellen, die Sie abfragen möchten.

Fügen Sie schließlich der DAO-Klasse eine Methode hinzu, um die Abfragefunktion verfügbar zu machen, die Ihre App benötigt. Für diese Methode müssen mehrere Abfragen in Room ausgeführt werden. Fügen Sie daher die @Transaction Annotation hinzu, damit der gesamte Vorgang atomar ausgeführt wird:

Kotlin

@Transaction
@Query("SELECT * FROM User")
fun getUsersWithPlaylistsAndSongs(): List<UserWithPlaylistsAndSongs>

Java

@Transaction
@Query("SELECT * FROM User")
public List<UserWithPlaylistsAndSongs> getUsersWithPlaylistsAndSongs();