1:1-Beziehungen definieren und abfragen

Eine 1:1-Beziehung zwischen zwei Entitäten ist eine Beziehung, bei der jede Instanz der übergeordneten Entität genau einer Instanz der untergeordneten Entität entspricht und umgekehrt.

Nehmen wir beispielsweise eine Musikstreaming-App, in der der Nutzer eine Mediathek mit Songs hat, deren Eigentümer er ist. Jeder Nutzer hat nur eine Mediathek und jede Mediathek entspricht genau einem Nutzer. Daher besteht eine 1:1-Beziehung zwischen der Entität User und der Entität Library.

So definieren und fragen Sie 1:1-Beziehungen in Ihrer Datenbank ab:

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

Beziehung definieren

Um eine 1:1-Beziehung zu definieren, erstellen Sie zuerst eine Klasse für jede Ihrer beiden Entitäten. Eine der Entitäten muss eine Variable enthalten, die eine Referenz auf den Primärschlüssel der anderen Entität ist.

@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
)

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

Entitäten abfragen

Wenn Sie die Liste der Nutzer und der entsprechenden Mediatheken abfragen möchten, müssen Sie zuerst die 1:1-Beziehung zwischen den beiden Entitäten modellieren.

Erstellen Sie dazu eine neue Datenklasse, in der jede Instanz eine Instanz der übergeordneten Entität und die entsprechende Instanz 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 UserAndLibrary(
    @Embedded val user: User,
    @Relation(
         parentColumn = "userId",
         entityColumn = "userOwnerId"
    )
    val library: Library
)

public class UserAndLibrary {
    @Embedded public User user;
    @Relation(
         parentColumn = "userId",
         entityColumn = "userOwnerId"
    )
    public Library library;
}

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 muss Room zwei Abfragen ausführen. Fügen Sie dieser Methode daher die @Transaction Annotation hinzu. So wird sichergestellt, dass der gesamte Vorgang atomar ausgeführt wird.

@Transaction
@Query("SELECT * FROM User")
fun getUsersAndLibraries(): List<UserAndLibrary>

@Transaction
@Query("SELECT * FROM User")
public List<UserAndLibrary> getUsersAndLibraries();