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 ait la possibilité d'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, procédez comme suit:

1. Définir la relation: créez des classes pour les deux entités, l'entité enfant référençant la clé primaire de l'entité parente.
2. Interroger les entités: modélisez la relation dans une nouvelle classe de données et implémentez une méthode 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 les deux entités. 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
)

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

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 ce faire, créez une classe de données dans laquelle chaque instance contient une instance de l'entité parente et une liste de toutes les instances d'entité enfant correspondantes. Ajoutez l'annotation @Relation à l'instance de l'entité enfant, avec parentColumn défini sur le nom de la colonne de clé primaire de l'entité parente et entityColumn défini sur le nom de la colonne de l'entité enfant qui référence la clé primaire de l'entité parente.

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

Enfin, ajoutez une méthode à la classe DAO qui renvoie toutes les instances de la classe de données qui associent l'entité parente et l'entité enfant. Cette méthode nécessite que Room exécute deux requêtes. Vous devez donc ajouter l'annotation @Transaction à cette méthode pour que l'ensemble de l'opération soit effectué de manière atomique.

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

@Transaction
@Query("SELECT * FROM User")
public List<UserWithPlaylists> getUsersWithPlaylists();