1:n-Beziehungen definieren und abfragen

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

Nehmen wir als Beispiel eine Musikstreaming-App, in der Nutzer ihre Songs in Playlists organisieren können. 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 fragen Sie 1:n-Beziehungen in Ihrer Datenbank ab:

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

Um eine 1:n-Beziehung zu definieren, 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 ein Verweis auf den Primärschlüssel der übergeordneten Entität ist.

@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

Um die Liste der Nutzer und die entsprechenden Playlists abzufragen, müssen Sie zuerst die 1:n-Beziehung 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 Instanzen der untergeordneten Entität enthält. Fügen Sie der Instanz der untergeordneten Entität die @Relation Annotation hinzu. Setzen Sie parentColumn auf den Namen der Primärschlüsselspalte der übergeordneten Entität und entityColumn auf den Namen der Spalte der untergeordneten Entität, 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 schließlich eine Methode hinzu, die alle Instanzen der Datenklasse zurückgibt, die die übergeordnete und die untergeordnete Entität zusammenführt. Für diese Methode müssen zwei Abfragen in Room ausgeführt werden. Fügen Sie daher die @Transaction Annotation 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();