Definir e consultar relações "um para um"

Em um relação de um para um entre duas entidades, cada instância da entidade pai corresponde exatamente a uma instância da entidade filha. O inverso também é verdadeiro.

Por exemplo, considere um app de streaming de música em que o usuário tem uma biblioteca de músicas que pertencem a ele. Cada usuário tem apenas uma biblioteca, e cada biblioteca corresponde exatamente a um usuário. Portanto, há uma relação direta entre a entidade User e a entidade Library.

Siga estas etapas para definir e consultar relações de um para um no seu banco de dados:

  1. Defina a relação: crie classes para as duas entidades e verifique se uma faz referência à chave primária da outra.
  2. Consulte as entidades: modele a relação em uma nova classe de dados, e crie uma função para recuperar os dados relacionados.

Definir a relação

Para definir uma relação de um para um, crie uma classe para cada entidade. Uma das entidades precisa incluir uma variável que faça referência à chave primária da outra.

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

Consultar as entidades

Para consultar a lista de usuários e bibliotecas correspondentes, primeiro você precisa modelar a relação de um para um entre as duas entidades.

Para modelar a relação, crie uma nova classe de dados em que cada instância contenha uma instância da entidade pai e a entidade filha correspondente. Adicione a @Relation anotação à entidade filha. Defina parentColumns como o nome da coluna de chave primária da entidade pai e defina entityColumns como o nome da coluna da entidade filha que faz referência à chave primária da entidade pai.

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

Por fim, adicione uma função à classe de objeto de acesso a dados (DAO, na sigla em inglês) que retorna todas as instâncias da classe de dados que emparelha a entidade pai com a entidade filha. Adicione a @Transaction anotação para garantir que o Room execute toda a operação atomicamente, porque essa função exige que o Room execute duas consultas.

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

Chaves compostas

Se você definir a relação usando chaves compostas, especifique várias colunas em parentColumns e entityColumns. A ordem das colunas em parentColumns precisa corresponder à ordem das colunas em 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
)