1:n-Beziehungen definieren und abfragen

Eine 1:n-Beziehung zwischen zwei Entitäten ist eine Beziehung, bei der jeder Instanz der übergeordneten Entität null oder mehr Instanzen der untergeordneten Entität entsprechen, aber jede Instanz der untergeordneten Entität genau einer Instanz der übergeordneten Entität entsprechen kann.

Angenommen, in der Musik-Streaming-App können Nutzer ihre Titel in Playlists organisieren. Jeder Nutzer kann beliebig viele Playlists erstellen, aber jede Playlist wird von genau einem Nutzer erstellt. Daher besteht eine 1:n-Beziehung zwischen der Entität User und der Entität Playlist.

So definieren und abfragen Sie eine „Eins-zu-viele“-Beziehung in Ihrer Datenbank:

1. Beziehung definieren: Erstellen Sie Klassen für beide Entitäten, wobei die untergeordnete Entität auf den Primärschlüssel der übergeordneten Entität verweist.
2. Entitäten abfragen: Modellieren Sie die Beziehung in einer neuen Datenklasse und implementieren Sie eine Methode zum Abrufen der zugehörigen Daten.

Beziehung definieren

Wenn Sie eine 1:n-Beziehung definieren möchten, erstellen Sie zuerst eine Klasse für die beiden Entitäten. Wie bei einer 1:1-Beziehung muss die untergeordnete Entität eine Variable enthalten, die einen Verweis auf den Primärschlüssel der übergeordneten Entität enthält.

@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
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;
}

Entitäten abfragen

Wenn du die Liste der Nutzer und die entsprechenden Playlists abfragen möchtest, musst du zuerst die Beziehung „Eins zu Vieles“ zwischen den beiden Entitäten modellieren.

Erstellen Sie dazu eine neue Datenklasse, in der jede Instanz eine Instanz der übergeordneten Entität und eine Liste aller entsprechenden untergeordneten Entitätsinstanzen enthält. Fügen Sie der Instanz der untergeordneten Entität die Anmerkung @Relation hinzu. Dabei muss parentColumn auf den Namen der Primärschlüsselspalte der übergeordneten Entität und entityColumn auf den Namen der Spalte der untergeordneten Entität festgelegt sein, die auf den Primärschlüssel der übergeordneten Entität verweist.

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

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

Fügen Sie der DAO-Klasse abschließend eine Methode hinzu, die alle Instanzen der Datenklasse zurückgibt, die die übergeordnete Entität und die untergeordnete Entität zusammenführen. Für diese Methode muss Room zwei Abfragen ausführen. Fügen Sie dieser Methode daher die @Transaction-Anmerkung hinzu, damit der gesamte Vorgang atomar ausgeführt wird.

@Transaction
@Query("SELECT * FROM User")
fun getUsersWithPlaylists(): List<UserWithPlaylists>

@Transaction
@Query("SELECT * FROM User")
public List<UserWithPlaylists> getUsersWithPlaylists();