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 als Beispiel 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 Funktion 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 auf den Primärschlüssel der anderen Entität verweist.

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

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 untergeordnete Entität enthält. Fügen Sie der untergeordneten Entität die @Relation Annotation hinzu. Legen Sie parentColumns auf den Namen der Primärschlüsselspalte der übergeordneten Entität und legen Sie entityColumns auf den Namen der Spalte der untergeordneten Entität fest, die auf den Primärschlüssel der übergeordneten Entität verweist.

data class UserAndLibrary(
    @Embedded val user: User,
    @Relation(
        parentColumns = ["userId"],
        entityColumns = ["userOwnerId"]
    )
    val library: Library
)

Fügen Sie schließlich der DAO-Klasse (Data Access Object) eine Funktion hinzu, die alle Instanzen der Datenklasse zurückgibt, die die übergeordnete Entität mit der untergeordneten Entität verknüpft. Fügen Sie die @Transaction Annotation hinzu, damit Room den gesamten Vorgang atomar ausführt, da für diese Funktion zwei Abfragen in Room ausgeführt werden müssen.

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

Zusammengesetzte Schlüssel

Wenn Sie die Beziehung mit zusammengesetzten Schlüsseln definieren, geben Sie in parentColumns und entityColumns mehrere Spalten an. Die Reihenfolge der Spalten in parentColumns muss mit der Reihenfolge der Spalten in entityColumns übereinstimmen.

@Entity(primaryKeys = ["firstName", "lastName"])
data class User(
    val firstName: String,
    val lastName: String,
    val age: Int
)

@Entity
data class Library(
    @PrimaryKey val libraryId: Long,
    val userFirstName: String,
    val userLastName: String
)

data class UserAndLibrary(
    @Embedded val user: User,
    @Relation(
        parentColumns = ["firstName", "lastName"],
        entityColumns = ["userFirstName", "userLastName"]
    )
    val library: Library
)