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 biunivoques dans votre base de données, procédez comme suit:

1. Définir la relation: créez des classes pour les deux entités, en vous assurant que l'une référence la clé primaire de l'autre.
2. Interroger les entités: modélisez la relation dans une nouvelle classe de données et créez une méthode 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
)

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

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 ce faire, créez une classe de données dans laquelle chaque instance contient une instance de l'entité parente et l'instance correspondante de l'entité enfant. 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 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;
}

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. Cela garantit que l'ensemble de l'opération s'exécute de manière atomique.

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

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