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

Une relation de type un à plusieurs entre deux entités est une relation dans laquelle chaque instance de l'entité parente correspond à aucune ou plusieurs instances de l'entité enfant, mais chaque instance de l'entité enfant ne peut correspondre qu'à une seule instance de l'entité parente.

Pour reprendre l'exemple de l'application de streaming musical, supposons que l'utilisateur puisse organiser ses titres dans des playlists. Chaque utilisateur peut créer autant de playlists qu'il le souhaite, mais chaque playlist ne peut être créée que par un seul utilisateur. Par conséquent, il existe une relation de type un à plusieurs entre l'entité User et l'entité Playlist.

Pour définir et interroger des relations de type un à plusieurs dans votre base de données :

  1. Définissez la relation : créez des classes pour les deux entités, l'entité enfant faisant référence à la clé primaire du parent.
  2. Interrogez les entités : modélisez la relation dans une nouvelle classe de données et implémentez une fonction pour récupérer les données associées.

Définir la relation

Pour définir une relation de type un à plusieurs, créez d'abord une classe pour chaque entité. Comme dans le cadre d'une relation de type un à un, l'entité enfant doit inclure une variable qui fait référence à la clé primaire de l'entité parente.

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

Interroger les entités

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

Pour modéliser la relation, créez une classe de données. Chaque instance de cette classe contient une instance de l'entité parente et une liste de toutes les instances d'entité enfant correspondantes. Ajoutez l'annotation @Relation à la propriété qui représente la liste des entités enfants. Définissez parentColumns sur le nom de la colonne de clé primaire de l'entité parente et entityColumns sur le nom de la colonne de l'entité enfant qui fait référence à la clé primaire de l'entité parente.

data class UserWithPlaylists(
    @Embedded val user: User,
    @Relation(
        parentColumns = ["userId"],
        entityColumns = ["userCreatorId"]
    )
    val playlists: List<Playlist>
)

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 associant l'entité parente et l'entité enfant. Ajoutez l'annotation @Transaction pour que Room effectue l'ensemble de l'opération de manière atomique. Cette annotation est nécessaire, car la fonction nécessite que Room exécute deux requêtes.

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

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 Playlist(
    @PrimaryKey val playlistId: Long,
    val userFirstName: String,
    val userLastName: String,
    val playlistName: String
)

data class UserWithPlaylists(
    @Embedded val user: User,
    @Relation(
        parentColumns = ["firstName", "lastName"],
        entityColumns = ["userFirstName", "userLastName"]
    )
    val playlists: List<Playlist>
)