Définir et interroger des relations de type un à un

Une relation de type un à un entre deux entités est une relation dans laquelle chaque instance de l'entité parente correspond exactement à une instance de l'entité enfant, et inversement.

Prenons l'exemple d'une application de streaming musical où l'utilisateur possède une bibliothèque de titres dont il est propriétaire. Chaque utilisateur ne possède qu'une seule bibliothèque, qui correspond chacune à un seul utilisateur. Par conséquent, il existe une relation de type un à un entre l'entité User et l'entité Library.

Pour définir et interroger des relations de type un à un dans votre base de données, procédez comme suit :

  1. Définissez la relation : créez des classes pour les deux entités et assurez-vous que l'une fait référence à la clé primaire de l'autre.
  2. Interrogez les entités : modélisez la relation dans une nouvelle classe de données, et créez une fonction pour récupérer les données associées.

Définir la relation

Pour définir une relation de type un à un, créez d'abord une classe pour chacune de vos deux entités. L'une des entités doit inclure une variable qui fait référence à la clé primaire de l'autre entité.

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

Interroger les entités

Pour interroger la liste des utilisateurs et des bibliothèques correspondantes, vous devez d'abord représenter la relation de type un à un entre les deux entités.

Pour modéliser la relation, créez une classe de données dans laquelle chaque instance contient une instance de l'entité parente et l'entité enfant correspondante. Ajoutez l' @Relation annotation à l'entité enfant. Définissez parentColumns sur le nom de la colonne de clé primaire de l'entité parente et définissez entityColumns sur le nom de la colonne de l'entité enfant qui fait référence à la clé primaire du parent.

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

Enfin, ajoutez une fonction à la classe d'objet d'accès aux données (DAO) qui renvoie toutes les instances de la classe de données qui associent l'entité parente à l'entité enfant. Ajoutez l'annotation @Transaction pour vous assurer que Room effectue l'opération entière de manière atomique, car cette fonction nécessite que Room exécute deux requêtes.

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

Clés composites

Si vous définissez la relation à l'aide de clés composites, spécifiez plusieurs colonnes dans parentColumns et entityColumns. L'ordre des colonnes dans parentColumns doit correspondre à celui des colonnes dans entityColumns.

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